// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.33.2
// source: envoy/config/endpoint/v3/endpoint_components.proto

package endpointv3

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

// Upstream host identifier.
type Endpoint struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The upstream host address.
	//
	// .. attention::
	//
	//	The form of host address depends on the given cluster type. For STATIC or EDS,
	//	it is expected to be a direct IP address (or something resolvable by the
	//	specified :ref:`resolver <envoy_v3_api_field_config.core.v3.SocketAddress.resolver_name>`
	//	in the Address). For LOGICAL or STRICT DNS, it is expected to be hostname,
	//	and will be resolved via DNS.
	Address *v3.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// The optional health check configuration is used as configuration for the
	// health checker to contact the health checked host.
	//
	// .. attention::
	//
	//	This takes into effect only for upstream clusters with
	//	:ref:`active health checking <arch_overview_health_checking>` enabled.
	HealthCheckConfig *Endpoint_HealthCheckConfig `protobuf:"bytes,2,opt,name=health_check_config,json=healthCheckConfig,proto3" json:"health_check_config,omitempty"`
	// The hostname associated with this endpoint. This hostname is not used for routing or address
	// resolution. If provided, it will be associated with the endpoint, and can be used for features
	// that require a hostname, like
	// :ref:`auto_host_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.auto_host_rewrite>`.
	Hostname string `protobuf:"bytes,3,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// An ordered list of addresses that together with “address“ comprise the
	// list of addresses for an endpoint. The address given in the “address“ is
	// prepended to this list. It is assumed that the list must already be
	// sorted by preference order of the addresses. This will only be supported
	// for STATIC and EDS clusters.
	AdditionalAddresses []*Endpoint_AdditionalAddress `protobuf:"bytes,4,rep,name=additional_addresses,json=additionalAddresses,proto3" json:"additional_addresses,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*Endpoint) ProtoMessage() {}

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

func (x *Endpoint) GetAddress() *v3.Address {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *Endpoint) GetHealthCheckConfig() *Endpoint_HealthCheckConfig {
	if x != nil {
		return x.HealthCheckConfig
	}
	return nil
}

func (x *Endpoint) GetHostname() string {
	if x != nil {
		return x.Hostname
	}
	return ""
}

func (x *Endpoint) GetAdditionalAddresses() []*Endpoint_AdditionalAddress {
	if x != nil {
		return x.AdditionalAddresses
	}
	return nil
}

// An Endpoint that Envoy can route traffic to.
// [#next-free-field: 6]
type LbEndpoint struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Upstream host identifier or a named reference.
	//
	// Types that are valid to be assigned to HostIdentifier:
	//
	//	*LbEndpoint_Endpoint
	//	*LbEndpoint_EndpointName
	HostIdentifier isLbEndpoint_HostIdentifier `protobuf_oneof:"host_identifier"`
	// Optional health status when known and supplied by EDS server.
	HealthStatus v3.HealthStatus `protobuf:"varint,2,opt,name=health_status,json=healthStatus,proto3,enum=envoy.config.core.v3.HealthStatus" json:"health_status,omitempty"`
	// The endpoint metadata specifies values that may be used by the load
	// balancer to select endpoints in a cluster for a given request. The filter
	// name should be specified as “envoy.lb“. An example boolean key-value pair
	// is “canary“, providing the optional canary status of the upstream host.
	// This may be matched against in a route's
	// :ref:`RouteAction <envoy_v3_api_msg_config.route.v3.RouteAction>` metadata_match field
	// to subset the endpoints considered in cluster load balancing.
	Metadata *v3.Metadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// The optional load balancing weight of the upstream host; at least 1.
	// Envoy uses the load balancing weight in some of the built in load
	// balancers. The load balancing weight for an endpoint is divided by the sum
	// of the weights of all endpoints in the endpoint's locality to produce a
	// percentage of traffic for the endpoint. This percentage is then further
	// weighted by the endpoint's locality's load balancing weight from
	// LocalityLbEndpoints. If unspecified, will be treated as 1. The sum
	// of the weights of all endpoints in the endpoint's locality must not
	// exceed uint32_t maximal value (4294967295).
	LoadBalancingWeight *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=load_balancing_weight,json=loadBalancingWeight,proto3" json:"load_balancing_weight,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*LbEndpoint) ProtoMessage() {}

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

func (x *LbEndpoint) GetHostIdentifier() isLbEndpoint_HostIdentifier {
	if x != nil {
		return x.HostIdentifier
	}
	return nil
}

func (x *LbEndpoint) GetEndpoint() *Endpoint {
	if x != nil {
		if x, ok := x.HostIdentifier.(*LbEndpoint_Endpoint); ok {
			return x.Endpoint
		}
	}
	return nil
}

func (x *LbEndpoint) GetEndpointName() string {
	if x != nil {
		if x, ok := x.HostIdentifier.(*LbEndpoint_EndpointName); ok {
			return x.EndpointName
		}
	}
	return ""
}

func (x *LbEndpoint) GetHealthStatus() v3.HealthStatus {
	if x != nil {
		return x.HealthStatus
	}
	return v3.HealthStatus(0)
}

func (x *LbEndpoint) GetMetadata() *v3.Metadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *LbEndpoint) GetLoadBalancingWeight() *wrapperspb.UInt32Value {
	if x != nil {
		return x.LoadBalancingWeight
	}
	return nil
}

type isLbEndpoint_HostIdentifier interface {
	isLbEndpoint_HostIdentifier()
}

type LbEndpoint_Endpoint struct {
	Endpoint *Endpoint `protobuf:"bytes,1,opt,name=endpoint,proto3,oneof"`
}

type LbEndpoint_EndpointName struct {
	// [#not-implemented-hide:]
	EndpointName string `protobuf:"bytes,5,opt,name=endpoint_name,json=endpointName,proto3,oneof"`
}

func (*LbEndpoint_Endpoint) isLbEndpoint_HostIdentifier() {}

func (*LbEndpoint_EndpointName) isLbEndpoint_HostIdentifier() {}

// LbEndpoint list collection. Entries are `LbEndpoint` resources or references.
// [#not-implemented-hide:]
type LbEndpointCollection struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       *v31.CollectionEntry   `protobuf:"bytes,1,opt,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LbEndpointCollection) ProtoMessage() {}

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

func (x *LbEndpointCollection) GetEntries() *v31.CollectionEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

// A configuration for an LEDS collection.
type LedsClusterLocalityConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configuration for the source of LEDS updates for a Locality.
	LedsConfig *v3.ConfigSource `protobuf:"bytes,1,opt,name=leds_config,json=ledsConfig,proto3" json:"leds_config,omitempty"`
	// The name of the LbEndpoint collection resource.
	//
	// If the name ends in “/*“, it indicates an LbEndpoint glob collection,
	// which is supported only in the xDS incremental protocol variants.
	// Otherwise, it indicates an LbEndpointCollection list collection.
	//
	// Envoy currently supports only glob collections.
	LedsCollectionName string `protobuf:"bytes,2,opt,name=leds_collection_name,json=ledsCollectionName,proto3" json:"leds_collection_name,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*LedsClusterLocalityConfig) ProtoMessage() {}

func (x *LedsClusterLocalityConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_config_endpoint_v3_endpoint_components_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 LedsClusterLocalityConfig.ProtoReflect.Descriptor instead.
func (*LedsClusterLocalityConfig) Descriptor() ([]byte, []int) {
	return file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescGZIP(), []int{3}
}

func (x *LedsClusterLocalityConfig) GetLedsConfig() *v3.ConfigSource {
	if x != nil {
		return x.LedsConfig
	}
	return nil
}

func (x *LedsClusterLocalityConfig) GetLedsCollectionName() string {
	if x != nil {
		return x.LedsCollectionName
	}
	return ""
}

// A group of endpoints belonging to a Locality.
// One can have multiple LocalityLbEndpoints for a locality, but only if
// they have different priorities.
// [#next-free-field: 10]
type LocalityLbEndpoints struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Identifies location of where the upstream hosts run.
	Locality *v3.Locality `protobuf:"bytes,1,opt,name=locality,proto3" json:"locality,omitempty"`
	// Metadata to provide additional information about the locality endpoints in aggregate.
	Metadata *v3.Metadata `protobuf:"bytes,9,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// The group of endpoints belonging to the locality specified.
	// This is ignored if :ref:`leds_cluster_locality_config
	// <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.leds_cluster_locality_config>` is set.
	LbEndpoints []*LbEndpoint `protobuf:"bytes,2,rep,name=lb_endpoints,json=lbEndpoints,proto3" json:"lb_endpoints,omitempty"`
	// Types that are valid to be assigned to LbConfig:
	//
	//	*LocalityLbEndpoints_LoadBalancerEndpoints
	//	*LocalityLbEndpoints_LedsClusterLocalityConfig
	LbConfig isLocalityLbEndpoints_LbConfig `protobuf_oneof:"lb_config"`
	// Optional: Per priority/region/zone/sub_zone weight; at least 1. The load
	// balancing weight for a locality is divided by the sum of the weights of all
	// localities  at the same priority level to produce the effective percentage
	// of traffic for the locality. The sum of the weights of all localities at
	// the same priority level must not exceed uint32_t maximal value (4294967295).
	//
	// Locality weights are only considered when :ref:`locality weighted load
	// balancing <arch_overview_load_balancing_locality_weighted_lb>` is
	// configured. These weights are ignored otherwise. If no weights are
	// specified when locality weighted load balancing is enabled, the locality is
	// assigned no load.
	LoadBalancingWeight *wrapperspb.UInt32Value `protobuf:"bytes,3,opt,name=load_balancing_weight,json=loadBalancingWeight,proto3" json:"load_balancing_weight,omitempty"`
	// Optional: the priority for this LocalityLbEndpoints. If unspecified this will
	// default to the highest priority (0).
	//
	// Under usual circumstances, Envoy will only select endpoints for the highest
	// priority (0). In the event that enough endpoints for a particular priority are
	// unavailable/unhealthy, Envoy will fail over to selecting endpoints for the
	// next highest priority group. Read more at :ref:`priority levels <arch_overview_load_balancing_priority_levels>`.
	//
	// Priorities should range from 0 (highest) to N (lowest) without skipping.
	Priority uint32 `protobuf:"varint,5,opt,name=priority,proto3" json:"priority,omitempty"`
	// Optional: Per locality proximity value which indicates how close this
	// locality is from the source locality. This value only provides ordering
	// information (lower the value, closer it is to the source locality).
	// This will be consumed by load balancing schemes that need proximity order
	// to determine where to route the requests.
	// [#not-implemented-hide:]
	Proximity     *wrapperspb.UInt32Value `protobuf:"bytes,6,opt,name=proximity,proto3" json:"proximity,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LocalityLbEndpoints) ProtoMessage() {}

func (x *LocalityLbEndpoints) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_config_endpoint_v3_endpoint_components_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 LocalityLbEndpoints.ProtoReflect.Descriptor instead.
func (*LocalityLbEndpoints) Descriptor() ([]byte, []int) {
	return file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescGZIP(), []int{4}
}

func (x *LocalityLbEndpoints) GetLocality() *v3.Locality {
	if x != nil {
		return x.Locality
	}
	return nil
}

func (x *LocalityLbEndpoints) GetMetadata() *v3.Metadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *LocalityLbEndpoints) GetLbEndpoints() []*LbEndpoint {
	if x != nil {
		return x.LbEndpoints
	}
	return nil
}

func (x *LocalityLbEndpoints) GetLbConfig() isLocalityLbEndpoints_LbConfig {
	if x != nil {
		return x.LbConfig
	}
	return nil
}

// Deprecated: Marked as deprecated in envoy/config/endpoint/v3/endpoint_components.proto.
func (x *LocalityLbEndpoints) GetLoadBalancerEndpoints() *LocalityLbEndpoints_LbEndpointList {
	if x != nil {
		if x, ok := x.LbConfig.(*LocalityLbEndpoints_LoadBalancerEndpoints); ok {
			return x.LoadBalancerEndpoints
		}
	}
	return nil
}

func (x *LocalityLbEndpoints) GetLedsClusterLocalityConfig() *LedsClusterLocalityConfig {
	if x != nil {
		if x, ok := x.LbConfig.(*LocalityLbEndpoints_LedsClusterLocalityConfig); ok {
			return x.LedsClusterLocalityConfig
		}
	}
	return nil
}

func (x *LocalityLbEndpoints) GetLoadBalancingWeight() *wrapperspb.UInt32Value {
	if x != nil {
		return x.LoadBalancingWeight
	}
	return nil
}

func (x *LocalityLbEndpoints) GetPriority() uint32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *LocalityLbEndpoints) GetProximity() *wrapperspb.UInt32Value {
	if x != nil {
		return x.Proximity
	}
	return nil
}

type isLocalityLbEndpoints_LbConfig interface {
	isLocalityLbEndpoints_LbConfig()
}

type LocalityLbEndpoints_LoadBalancerEndpoints struct {
	// [#not-implemented-hide:]
	// Not implemented and deprecated.
	//
	// Deprecated: Marked as deprecated in envoy/config/endpoint/v3/endpoint_components.proto.
	LoadBalancerEndpoints *LocalityLbEndpoints_LbEndpointList `protobuf:"bytes,7,opt,name=load_balancer_endpoints,json=loadBalancerEndpoints,proto3,oneof"`
}

type LocalityLbEndpoints_LedsClusterLocalityConfig struct {
	// LEDS Configuration for the current locality.
	// If this is set, the :ref:`lb_endpoints
	// <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.lb_endpoints>`
	// field is ignored.
	LedsClusterLocalityConfig *LedsClusterLocalityConfig `protobuf:"bytes,8,opt,name=leds_cluster_locality_config,json=ledsClusterLocalityConfig,proto3,oneof"`
}

func (*LocalityLbEndpoints_LoadBalancerEndpoints) isLocalityLbEndpoints_LbConfig() {}

func (*LocalityLbEndpoints_LedsClusterLocalityConfig) isLocalityLbEndpoints_LbConfig() {}

// The optional health check configuration.
type Endpoint_HealthCheckConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Optional alternative health check port value.
	//
	// By default the health check address port of an upstream host is the same
	// as the host's serving address port. This provides an alternative health
	// check port. Setting this with a non-zero value allows an upstream host
	// to have different health check address port.
	PortValue uint32 `protobuf:"varint,1,opt,name=port_value,json=portValue,proto3" json:"port_value,omitempty"`
	// By default, the host header for L7 health checks is controlled by cluster level configuration
	// (see: :ref:`host <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.host>` and
	// :ref:`authority <envoy_v3_api_field_config.core.v3.HealthCheck.GrpcHealthCheck.authority>`). Setting this
	// to a non-empty value allows overriding the cluster level configuration for a specific
	// endpoint.
	Hostname string `protobuf:"bytes,2,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// Optional alternative health check host address.
	//
	// .. attention::
	//
	//	The form of the health check host address is expected to be a direct IP address.
	Address *v3.Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
	// Optional flag to control if perform active health check for this endpoint.
	// Active health check is enabled by default if there is a health checker.
	DisableActiveHealthCheck bool `protobuf:"varint,4,opt,name=disable_active_health_check,json=disableActiveHealthCheck,proto3" json:"disable_active_health_check,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

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

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

func (*Endpoint_HealthCheckConfig) ProtoMessage() {}

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

func (x *Endpoint_HealthCheckConfig) GetPortValue() uint32 {
	if x != nil {
		return x.PortValue
	}
	return 0
}

func (x *Endpoint_HealthCheckConfig) GetHostname() string {
	if x != nil {
		return x.Hostname
	}
	return ""
}

func (x *Endpoint_HealthCheckConfig) GetAddress() *v3.Address {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *Endpoint_HealthCheckConfig) GetDisableActiveHealthCheck() bool {
	if x != nil {
		return x.DisableActiveHealthCheck
	}
	return false
}

type Endpoint_AdditionalAddress struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Additional address that is associated with the endpoint.
	Address       *v3.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Endpoint_AdditionalAddress) ProtoMessage() {}

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

func (x *Endpoint_AdditionalAddress) GetAddress() *v3.Address {
	if x != nil {
		return x.Address
	}
	return nil
}

// [#not-implemented-hide:]
// A list of endpoints of a specific locality.
type LocalityLbEndpoints_LbEndpointList struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	LbEndpoints   []*LbEndpoint          `protobuf:"bytes,1,rep,name=lb_endpoints,json=lbEndpoints,proto3" json:"lb_endpoints,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LocalityLbEndpoints_LbEndpointList) ProtoMessage() {}

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

func (x *LocalityLbEndpoints_LbEndpointList) GetLbEndpoints() []*LbEndpoint {
	if x != nil {
		return x.LbEndpoints
	}
	return nil
}

var File_envoy_config_endpoint_v3_endpoint_components_proto protoreflect.FileDescriptor

const file_envoy_config_endpoint_v3_endpoint_components_proto_rawDesc = "" +
	"\n" +
	"2envoy/config/endpoint/v3/endpoint_components.proto\x12\x18envoy.config.endpoint.v3\x1a\"envoy/config/core/v3/address.proto\x1a\x1fenvoy/config/core/v3/base.proto\x1a(envoy/config/core/v3/config_source.proto\x1a'envoy/config/core/v3/health_check.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a\"xds/core/v3/collection_entry.proto\x1a#envoy/annotations/deprecation.proto\x1a\x1dudpa/annotations/status.proto\x1a!udpa/annotations/versioning.proto\x1a\x17validate/validate.proto\"\xb0\x05\n" +
	"\bEndpoint\x127\n" +
	"\aaddress\x18\x01 \x01(\v2\x1d.envoy.config.core.v3.AddressR\aaddress\x12d\n" +
	"\x13health_check_config\x18\x02 \x01(\v24.envoy.config.endpoint.v3.Endpoint.HealthCheckConfigR\x11healthCheckConfig\x12\x1a\n" +
	"\bhostname\x18\x03 \x01(\tR\bhostname\x12g\n" +
	"\x14additional_addresses\x18\x04 \x03(\v24.envoy.config.endpoint.v3.Endpoint.AdditionalAddressR\x13additionalAddresses\x1a\x8a\x02\n" +
	"\x11HealthCheckConfig\x12(\n" +
	"\n" +
	"port_value\x18\x01 \x01(\rB\t\xfaB\x06*\x04\x18\xff\xff\x03R\tportValue\x12\x1a\n" +
	"\bhostname\x18\x02 \x01(\tR\bhostname\x127\n" +
	"\aaddress\x18\x03 \x01(\v2\x1d.envoy.config.core.v3.AddressR\aaddress\x12=\n" +
	"\x1bdisable_active_health_check\x18\x04 \x01(\bR\x18disableActiveHealthCheck:7\x9aň\x1e2\n" +
	"0envoy.api.v2.endpoint.Endpoint.HealthCheckConfig\x1aL\n" +
	"\x11AdditionalAddress\x127\n" +
	"\aaddress\x18\x01 \x01(\v2\x1d.envoy.config.core.v3.AddressR\aaddress:%\x9aň\x1e \n" +
	"\x1eenvoy.api.v2.endpoint.Endpoint\"\x91\x03\n" +
	"\n" +
	"LbEndpoint\x12@\n" +
	"\bendpoint\x18\x01 \x01(\v2\".envoy.config.endpoint.v3.EndpointH\x00R\bendpoint\x12%\n" +
	"\rendpoint_name\x18\x05 \x01(\tH\x00R\fendpointName\x12G\n" +
	"\rhealth_status\x18\x02 \x01(\x0e2\".envoy.config.core.v3.HealthStatusR\fhealthStatus\x12:\n" +
	"\bmetadata\x18\x03 \x01(\v2\x1e.envoy.config.core.v3.MetadataR\bmetadata\x12Y\n" +
	"\x15load_balancing_weight\x18\x04 \x01(\v2\x1c.google.protobuf.UInt32ValueB\a\xfaB\x04*\x02(\x01R\x13loadBalancingWeight:'\x9aň\x1e\"\n" +
	" envoy.api.v2.endpoint.LbEndpointB\x11\n" +
	"\x0fhost_identifier\"N\n" +
	"\x14LbEndpointCollection\x126\n" +
	"\aentries\x18\x01 \x01(\v2\x1c.xds.core.v3.CollectionEntryR\aentries\"\x92\x01\n" +
	"\x19LedsClusterLocalityConfig\x12C\n" +
	"\vleds_config\x18\x01 \x01(\v2\".envoy.config.core.v3.ConfigSourceR\n" +
	"ledsConfig\x120\n" +
	"\x14leds_collection_name\x18\x02 \x01(\tR\x12ledsCollectionName\"\xab\x06\n" +
	"\x13LocalityLbEndpoints\x12:\n" +
	"\blocality\x18\x01 \x01(\v2\x1e.envoy.config.core.v3.LocalityR\blocality\x12:\n" +
	"\bmetadata\x18\t \x01(\v2\x1e.envoy.config.core.v3.MetadataR\bmetadata\x12G\n" +
	"\flb_endpoints\x18\x02 \x03(\v2$.envoy.config.endpoint.v3.LbEndpointR\vlbEndpoints\x12\x83\x01\n" +
	"\x17load_balancer_endpoints\x18\a \x01(\v2<.envoy.config.endpoint.v3.LocalityLbEndpoints.LbEndpointListB\v\x92ǆ\xd8\x04\x033.0\x18\x01H\x00R\x15loadBalancerEndpoints\x12v\n" +
	"\x1cleds_cluster_locality_config\x18\b \x01(\v23.envoy.config.endpoint.v3.LedsClusterLocalityConfigH\x00R\x19ledsClusterLocalityConfig\x12Y\n" +
	"\x15load_balancing_weight\x18\x03 \x01(\v2\x1c.google.protobuf.UInt32ValueB\a\xfaB\x04*\x02(\x01R\x13loadBalancingWeight\x12$\n" +
	"\bpriority\x18\x05 \x01(\rB\b\xfaB\x05*\x03\x18\x80\x01R\bpriority\x12:\n" +
	"\tproximity\x18\x06 \x01(\v2\x1c.google.protobuf.UInt32ValueR\tproximity\x1aY\n" +
	"\x0eLbEndpointList\x12G\n" +
	"\flb_endpoints\x18\x01 \x03(\v2$.envoy.config.endpoint.v3.LbEndpointR\vlbEndpoints:0\x9aň\x1e+\n" +
	")envoy.api.v2.endpoint.LocalityLbEndpointsB\v\n" +
	"\tlb_configB\x97\x01\xba\x80\xc8\xd1\x06\x02\x10\x02\n" +
	"&io.envoyproxy.envoy.config.endpoint.v3B\x17EndpointComponentsProtoP\x01ZJgithub.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3;endpointv3b\x06proto3"

var (
	file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescOnce sync.Once
	file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescData []byte
)

func file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescGZIP() []byte {
	file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescOnce.Do(func() {
		file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_envoy_config_endpoint_v3_endpoint_components_proto_rawDesc), len(file_envoy_config_endpoint_v3_endpoint_components_proto_rawDesc)))
	})
	return file_envoy_config_endpoint_v3_endpoint_components_proto_rawDescData
}

var file_envoy_config_endpoint_v3_endpoint_components_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_envoy_config_endpoint_v3_endpoint_components_proto_goTypes = []any{
	(*Endpoint)(nil),                           // 0: envoy.config.endpoint.v3.Endpoint
	(*LbEndpoint)(nil),                         // 1: envoy.config.endpoint.v3.LbEndpoint
	(*LbEndpointCollection)(nil),               // 2: envoy.config.endpoint.v3.LbEndpointCollection
	(*LedsClusterLocalityConfig)(nil),          // 3: envoy.config.endpoint.v3.LedsClusterLocalityConfig
	(*LocalityLbEndpoints)(nil),                // 4: envoy.config.endpoint.v3.LocalityLbEndpoints
	(*Endpoint_HealthCheckConfig)(nil),         // 5: envoy.config.endpoint.v3.Endpoint.HealthCheckConfig
	(*Endpoint_AdditionalAddress)(nil),         // 6: envoy.config.endpoint.v3.Endpoint.AdditionalAddress
	(*LocalityLbEndpoints_LbEndpointList)(nil), // 7: envoy.config.endpoint.v3.LocalityLbEndpoints.LbEndpointList
	(*v3.Address)(nil),                         // 8: envoy.config.core.v3.Address
	(v3.HealthStatus)(0),                       // 9: envoy.config.core.v3.HealthStatus
	(*v3.Metadata)(nil),                        // 10: envoy.config.core.v3.Metadata
	(*wrapperspb.UInt32Value)(nil),             // 11: google.protobuf.UInt32Value
	(*v31.CollectionEntry)(nil),                // 12: xds.core.v3.CollectionEntry
	(*v3.ConfigSource)(nil),                    // 13: envoy.config.core.v3.ConfigSource
	(*v3.Locality)(nil),                        // 14: envoy.config.core.v3.Locality
}
var file_envoy_config_endpoint_v3_endpoint_components_proto_depIdxs = []int32{
	8,  // 0: envoy.config.endpoint.v3.Endpoint.address:type_name -> envoy.config.core.v3.Address
	5,  // 1: envoy.config.endpoint.v3.Endpoint.health_check_config:type_name -> envoy.config.endpoint.v3.Endpoint.HealthCheckConfig
	6,  // 2: envoy.config.endpoint.v3.Endpoint.additional_addresses:type_name -> envoy.config.endpoint.v3.Endpoint.AdditionalAddress
	0,  // 3: envoy.config.endpoint.v3.LbEndpoint.endpoint:type_name -> envoy.config.endpoint.v3.Endpoint
	9,  // 4: envoy.config.endpoint.v3.LbEndpoint.health_status:type_name -> envoy.config.core.v3.HealthStatus
	10, // 5: envoy.config.endpoint.v3.LbEndpoint.metadata:type_name -> envoy.config.core.v3.Metadata
	11, // 6: envoy.config.endpoint.v3.LbEndpoint.load_balancing_weight:type_name -> google.protobuf.UInt32Value
	12, // 7: envoy.config.endpoint.v3.LbEndpointCollection.entries:type_name -> xds.core.v3.CollectionEntry
	13, // 8: envoy.config.endpoint.v3.LedsClusterLocalityConfig.leds_config:type_name -> envoy.config.core.v3.ConfigSource
	14, // 9: envoy.config.endpoint.v3.LocalityLbEndpoints.locality:type_name -> envoy.config.core.v3.Locality
	10, // 10: envoy.config.endpoint.v3.LocalityLbEndpoints.metadata:type_name -> envoy.config.core.v3.Metadata
	1,  // 11: envoy.config.endpoint.v3.LocalityLbEndpoints.lb_endpoints:type_name -> envoy.config.endpoint.v3.LbEndpoint
	7,  // 12: envoy.config.endpoint.v3.LocalityLbEndpoints.load_balancer_endpoints:type_name -> envoy.config.endpoint.v3.LocalityLbEndpoints.LbEndpointList
	3,  // 13: envoy.config.endpoint.v3.LocalityLbEndpoints.leds_cluster_locality_config:type_name -> envoy.config.endpoint.v3.LedsClusterLocalityConfig
	11, // 14: envoy.config.endpoint.v3.LocalityLbEndpoints.load_balancing_weight:type_name -> google.protobuf.UInt32Value
	11, // 15: envoy.config.endpoint.v3.LocalityLbEndpoints.proximity:type_name -> google.protobuf.UInt32Value
	8,  // 16: envoy.config.endpoint.v3.Endpoint.HealthCheckConfig.address:type_name -> envoy.config.core.v3.Address
	8,  // 17: envoy.config.endpoint.v3.Endpoint.AdditionalAddress.address:type_name -> envoy.config.core.v3.Address
	1,  // 18: envoy.config.endpoint.v3.LocalityLbEndpoints.LbEndpointList.lb_endpoints:type_name -> envoy.config.endpoint.v3.LbEndpoint
	19, // [19:19] is the sub-list for method output_type
	19, // [19:19] is the sub-list for method input_type
	19, // [19:19] is the sub-list for extension type_name
	19, // [19:19] is the sub-list for extension extendee
	0,  // [0:19] is the sub-list for field type_name
}

func init() { file_envoy_config_endpoint_v3_endpoint_components_proto_init() }
func file_envoy_config_endpoint_v3_endpoint_components_proto_init() {
	if File_envoy_config_endpoint_v3_endpoint_components_proto != nil {
		return
	}
	file_envoy_config_endpoint_v3_endpoint_components_proto_msgTypes[1].OneofWrappers = []any{
		(*LbEndpoint_Endpoint)(nil),
		(*LbEndpoint_EndpointName)(nil),
	}
	file_envoy_config_endpoint_v3_endpoint_components_proto_msgTypes[4].OneofWrappers = []any{
		(*LocalityLbEndpoints_LoadBalancerEndpoints)(nil),
		(*LocalityLbEndpoints_LedsClusterLocalityConfig)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_envoy_config_endpoint_v3_endpoint_components_proto_rawDesc), len(file_envoy_config_endpoint_v3_endpoint_components_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   8,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_envoy_config_endpoint_v3_endpoint_components_proto_goTypes,
		DependencyIndexes: file_envoy_config_endpoint_v3_endpoint_components_proto_depIdxs,
		MessageInfos:      file_envoy_config_endpoint_v3_endpoint_components_proto_msgTypes,
	}.Build()
	File_envoy_config_endpoint_v3_endpoint_components_proto = out.File
	file_envoy_config_endpoint_v3_endpoint_components_proto_goTypes = nil
	file_envoy_config_endpoint_v3_endpoint_components_proto_depIdxs = nil
}
