// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v7.35.1
// source: envoy/service/health/v3/hds.proto

package healthv3

import (
	_ "github.com/cncf/xds/go/udpa/annotations"
	_ "github.com/envoyproxy/go-control-plane/envoy/annotations"
	v32 "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3"
	v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
	v31 "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	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)
)

// Different Envoy instances may have different capabilities (e.g. Redis)
// and/or have ports enabled for different protocols.
type Capability_Protocol int32

const (
	Capability_HTTP  Capability_Protocol = 0
	Capability_TCP   Capability_Protocol = 1
	Capability_REDIS Capability_Protocol = 2
)

// Enum value maps for Capability_Protocol.
var (
	Capability_Protocol_name = map[int32]string{
		0: "HTTP",
		1: "TCP",
		2: "REDIS",
	}
	Capability_Protocol_value = map[string]int32{
		"HTTP":  0,
		"TCP":   1,
		"REDIS": 2,
	}
)

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

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

func (Capability_Protocol) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_service_health_v3_hds_proto_enumTypes[0].Descriptor()
}

func (Capability_Protocol) Type() protoreflect.EnumType {
	return &file_envoy_service_health_v3_hds_proto_enumTypes[0]
}

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

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

// Defines supported protocols etc, so the management server can assign proper
// endpoints to healthcheck.
type Capability struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	HealthCheckProtocols []Capability_Protocol  `protobuf:"varint,1,rep,packed,name=health_check_protocols,json=healthCheckProtocols,proto3,enum=envoy.service.health.v3.Capability_Protocol" json:"health_check_protocols,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*Capability) ProtoMessage() {}

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

func (x *Capability) GetHealthCheckProtocols() []Capability_Protocol {
	if x != nil {
		return x.HealthCheckProtocols
	}
	return nil
}

type HealthCheckRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Node          *v3.Node               `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	Capability    *Capability            `protobuf:"bytes,2,opt,name=capability,proto3" json:"capability,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthCheckRequest) ProtoMessage() {}

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

func (x *HealthCheckRequest) GetNode() *v3.Node {
	if x != nil {
		return x.Node
	}
	return nil
}

func (x *HealthCheckRequest) GetCapability() *Capability {
	if x != nil {
		return x.Capability
	}
	return nil
}

type EndpointHealth struct {
	state        protoimpl.MessageState `protogen:"open.v1"`
	Endpoint     *v31.Endpoint          `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	HealthStatus v3.HealthStatus        `protobuf:"varint,2,opt,name=health_status,json=healthStatus,proto3,enum=envoy.config.core.v3.HealthStatus" json:"health_status,omitempty"`
	// Optional metadata about the health check result, populated by the active
	// health checker and forwarded to the management server for richer health
	// state interpretation.
	//
	// Well-known keys:
	//
	// “http_status_code“ (number)
	//
	//	Set by the HTTP health checker. Contains the HTTP response status code
	//	returned by the upstream endpoint during the most recent health check,
	//	e.g. ``200``, ``503``. Only present when the health check received a
	//	complete HTTP response; absent on connection failures or timeouts.
	HealthMetadata *structpb.Struct `protobuf:"bytes,3,opt,name=health_metadata,json=healthMetadata,proto3" json:"health_metadata,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*EndpointHealth) ProtoMessage() {}

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

func (x *EndpointHealth) GetEndpoint() *v31.Endpoint {
	if x != nil {
		return x.Endpoint
	}
	return nil
}

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

func (x *EndpointHealth) GetHealthMetadata() *structpb.Struct {
	if x != nil {
		return x.HealthMetadata
	}
	return nil
}

// Group endpoint health by locality under each cluster.
type LocalityEndpointsHealth struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Locality        *v3.Locality           `protobuf:"bytes,1,opt,name=locality,proto3" json:"locality,omitempty"`
	EndpointsHealth []*EndpointHealth      `protobuf:"bytes,2,rep,name=endpoints_health,json=endpointsHealth,proto3" json:"endpoints_health,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*LocalityEndpointsHealth) ProtoMessage() {}

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

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

func (x *LocalityEndpointsHealth) GetEndpointsHealth() []*EndpointHealth {
	if x != nil {
		return x.EndpointsHealth
	}
	return nil
}

// The health status of endpoints in a cluster. The cluster name and locality
// should match the corresponding fields in ClusterHealthCheck message.
type ClusterEndpointsHealth struct {
	state                   protoimpl.MessageState     `protogen:"open.v1"`
	ClusterName             string                     `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
	LocalityEndpointsHealth []*LocalityEndpointsHealth `protobuf:"bytes,2,rep,name=locality_endpoints_health,json=localityEndpointsHealth,proto3" json:"locality_endpoints_health,omitempty"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

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

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

func (*ClusterEndpointsHealth) ProtoMessage() {}

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

func (x *ClusterEndpointsHealth) GetClusterName() string {
	if x != nil {
		return x.ClusterName
	}
	return ""
}

func (x *ClusterEndpointsHealth) GetLocalityEndpointsHealth() []*LocalityEndpointsHealth {
	if x != nil {
		return x.LocalityEndpointsHealth
	}
	return nil
}

type EndpointHealthResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Deprecated - Flat list of endpoint health information.
	//
	// Deprecated: Marked as deprecated in envoy/service/health/v3/hds.proto.
	EndpointsHealth []*EndpointHealth `protobuf:"bytes,1,rep,name=endpoints_health,json=endpointsHealth,proto3" json:"endpoints_health,omitempty"`
	// Organize Endpoint health information by cluster.
	ClusterEndpointsHealth []*ClusterEndpointsHealth `protobuf:"bytes,2,rep,name=cluster_endpoints_health,json=clusterEndpointsHealth,proto3" json:"cluster_endpoints_health,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*EndpointHealthResponse) ProtoMessage() {}

func (x *EndpointHealthResponse) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_service_health_v3_hds_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 EndpointHealthResponse.ProtoReflect.Descriptor instead.
func (*EndpointHealthResponse) Descriptor() ([]byte, []int) {
	return file_envoy_service_health_v3_hds_proto_rawDescGZIP(), []int{5}
}

// Deprecated: Marked as deprecated in envoy/service/health/v3/hds.proto.
func (x *EndpointHealthResponse) GetEndpointsHealth() []*EndpointHealth {
	if x != nil {
		return x.EndpointsHealth
	}
	return nil
}

func (x *EndpointHealthResponse) GetClusterEndpointsHealth() []*ClusterEndpointsHealth {
	if x != nil {
		return x.ClusterEndpointsHealth
	}
	return nil
}

type HealthCheckRequestOrEndpointHealthResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to RequestType:
	//
	//	*HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest
	//	*HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse
	RequestType   isHealthCheckRequestOrEndpointHealthResponse_RequestType `protobuf_oneof:"request_type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthCheckRequestOrEndpointHealthResponse) ProtoMessage() {}

func (x *HealthCheckRequestOrEndpointHealthResponse) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_service_health_v3_hds_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 HealthCheckRequestOrEndpointHealthResponse.ProtoReflect.Descriptor instead.
func (*HealthCheckRequestOrEndpointHealthResponse) Descriptor() ([]byte, []int) {
	return file_envoy_service_health_v3_hds_proto_rawDescGZIP(), []int{6}
}

func (x *HealthCheckRequestOrEndpointHealthResponse) GetRequestType() isHealthCheckRequestOrEndpointHealthResponse_RequestType {
	if x != nil {
		return x.RequestType
	}
	return nil
}

func (x *HealthCheckRequestOrEndpointHealthResponse) GetHealthCheckRequest() *HealthCheckRequest {
	if x != nil {
		if x, ok := x.RequestType.(*HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest); ok {
			return x.HealthCheckRequest
		}
	}
	return nil
}

func (x *HealthCheckRequestOrEndpointHealthResponse) GetEndpointHealthResponse() *EndpointHealthResponse {
	if x != nil {
		if x, ok := x.RequestType.(*HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse); ok {
			return x.EndpointHealthResponse
		}
	}
	return nil
}

type isHealthCheckRequestOrEndpointHealthResponse_RequestType interface {
	isHealthCheckRequestOrEndpointHealthResponse_RequestType()
}

type HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest struct {
	HealthCheckRequest *HealthCheckRequest `protobuf:"bytes,1,opt,name=health_check_request,json=healthCheckRequest,proto3,oneof"`
}

type HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse struct {
	EndpointHealthResponse *EndpointHealthResponse `protobuf:"bytes,2,opt,name=endpoint_health_response,json=endpointHealthResponse,proto3,oneof"`
}

func (*HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest) isHealthCheckRequestOrEndpointHealthResponse_RequestType() {
}

func (*HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse) isHealthCheckRequestOrEndpointHealthResponse_RequestType() {
}

type LocalityEndpoints struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Locality      *v3.Locality           `protobuf:"bytes,1,opt,name=locality,proto3" json:"locality,omitempty"`
	Endpoints     []*v31.Endpoint        `protobuf:"bytes,2,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LocalityEndpoints) ProtoMessage() {}

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

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

func (x *LocalityEndpoints) GetEndpoints() []*v31.Endpoint {
	if x != nil {
		return x.Endpoints
	}
	return nil
}

// The cluster name and locality is provided to Envoy for the endpoints that it
// health checks to support statistics reporting, logging and debugging by the
// Envoy instance (outside of HDS). For maximum usefulness, it should match the
// same cluster structure as that provided by EDS.
// [#next-free-field: 6]
type ClusterHealthCheck struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	ClusterName       string                 `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
	HealthChecks      []*v3.HealthCheck      `protobuf:"bytes,2,rep,name=health_checks,json=healthChecks,proto3" json:"health_checks,omitempty"`
	LocalityEndpoints []*LocalityEndpoints   `protobuf:"bytes,3,rep,name=locality_endpoints,json=localityEndpoints,proto3" json:"locality_endpoints,omitempty"`
	// Optional map that gets filtered by :ref:`health_checks.transport_socket_match_criteria <envoy_v3_api_field_config.core.v3.HealthCheck.transport_socket_match_criteria>`
	// on connection when health checking. For more details, see
	// :ref:`config.cluster.v3.Cluster.transport_socket_matches <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>`.
	TransportSocketMatches []*v32.Cluster_TransportSocketMatch `protobuf:"bytes,4,rep,name=transport_socket_matches,json=transportSocketMatches,proto3" json:"transport_socket_matches,omitempty"`
	// Optional configuration used to bind newly established upstream connections.
	// If the address and port are empty, no bind will be performed.
	UpstreamBindConfig *v3.BindConfig `protobuf:"bytes,5,opt,name=upstream_bind_config,json=upstreamBindConfig,proto3" json:"upstream_bind_config,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*ClusterHealthCheck) ProtoMessage() {}

func (x *ClusterHealthCheck) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_service_health_v3_hds_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 ClusterHealthCheck.ProtoReflect.Descriptor instead.
func (*ClusterHealthCheck) Descriptor() ([]byte, []int) {
	return file_envoy_service_health_v3_hds_proto_rawDescGZIP(), []int{8}
}

func (x *ClusterHealthCheck) GetClusterName() string {
	if x != nil {
		return x.ClusterName
	}
	return ""
}

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

func (x *ClusterHealthCheck) GetLocalityEndpoints() []*LocalityEndpoints {
	if x != nil {
		return x.LocalityEndpoints
	}
	return nil
}

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

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

type HealthCheckSpecifier struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	ClusterHealthChecks []*ClusterHealthCheck  `protobuf:"bytes,1,rep,name=cluster_health_checks,json=clusterHealthChecks,proto3" json:"cluster_health_checks,omitempty"`
	// The default is 1 second.
	Interval      *durationpb.Duration `protobuf:"bytes,2,opt,name=interval,proto3" json:"interval,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HealthCheckSpecifier) ProtoMessage() {}

func (x *HealthCheckSpecifier) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_service_health_v3_hds_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 HealthCheckSpecifier.ProtoReflect.Descriptor instead.
func (*HealthCheckSpecifier) Descriptor() ([]byte, []int) {
	return file_envoy_service_health_v3_hds_proto_rawDescGZIP(), []int{9}
}

func (x *HealthCheckSpecifier) GetClusterHealthChecks() []*ClusterHealthCheck {
	if x != nil {
		return x.ClusterHealthChecks
	}
	return nil
}

func (x *HealthCheckSpecifier) GetInterval() *durationpb.Duration {
	if x != nil {
		return x.Interval
	}
	return nil
}

// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
// services: https://github.com/google/protobuf/issues/4221 and protoxform to upgrade the file.
type HdsDummy struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HdsDummy) ProtoMessage() {}

func (x *HdsDummy) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_service_health_v3_hds_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 HdsDummy.ProtoReflect.Descriptor instead.
func (*HdsDummy) Descriptor() ([]byte, []int) {
	return file_envoy_service_health_v3_hds_proto_rawDescGZIP(), []int{10}
}

var File_envoy_service_health_v3_hds_proto protoreflect.FileDescriptor

const file_envoy_service_health_v3_hds_proto_rawDesc = "" +
	"\n" +
	"!envoy/service/health/v3/hds.proto\x12\x17envoy.service.health.v3\x1a%envoy/config/cluster/v3/cluster.proto\x1a\"envoy/config/core/v3/address.proto\x1a\x1fenvoy/config/core/v3/base.proto\x1a'envoy/config/core/v3/health_check.proto\x1a2envoy/config/endpoint/v3/endpoint_components.proto\x1a\x1cgoogle/api/annotations.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a#envoy/annotations/deprecation.proto\x1a\x1dudpa/annotations/status.proto\x1a!udpa/annotations/versioning.proto\"\xc8\x01\n" +
	"\n" +
	"Capability\x12b\n" +
	"\x16health_check_protocols\x18\x01 \x03(\x0e2,.envoy.service.health.v3.Capability.ProtocolR\x14healthCheckProtocols\"(\n" +
	"\bProtocol\x12\b\n" +
	"\x04HTTP\x10\x00\x12\a\n" +
	"\x03TCP\x10\x01\x12\t\n" +
	"\x05REDIS\x10\x02:,\x9aň\x1e'\n" +
	"%envoy.service.discovery.v2.Capability\"\xbf\x01\n" +
	"\x12HealthCheckRequest\x12.\n" +
	"\x04node\x18\x01 \x01(\v2\x1a.envoy.config.core.v3.NodeR\x04node\x12C\n" +
	"\n" +
	"capability\x18\x02 \x01(\v2#.envoy.service.health.v3.CapabilityR\n" +
	"capability:4\x9aň\x1e/\n" +
	"-envoy.service.discovery.v2.HealthCheckRequest\"\x8d\x02\n" +
	"\x0eEndpointHealth\x12>\n" +
	"\bendpoint\x18\x01 \x01(\v2\".envoy.config.endpoint.v3.EndpointR\bendpoint\x12G\n" +
	"\rhealth_status\x18\x02 \x01(\x0e2\".envoy.config.core.v3.HealthStatusR\fhealthStatus\x12@\n" +
	"\x0fhealth_metadata\x18\x03 \x01(\v2\x17.google.protobuf.StructR\x0ehealthMetadata:0\x9aň\x1e+\n" +
	")envoy.service.discovery.v2.EndpointHealth\"\xa9\x01\n" +
	"\x17LocalityEndpointsHealth\x12:\n" +
	"\blocality\x18\x01 \x01(\v2\x1e.envoy.config.core.v3.LocalityR\blocality\x12R\n" +
	"\x10endpoints_health\x18\x02 \x03(\v2'.envoy.service.health.v3.EndpointHealthR\x0fendpointsHealth\"\xa9\x01\n" +
	"\x16ClusterEndpointsHealth\x12!\n" +
	"\fcluster_name\x18\x01 \x01(\tR\vclusterName\x12l\n" +
	"\x19locality_endpoints_health\x18\x02 \x03(\v20.envoy.service.health.v3.LocalityEndpointsHealthR\x17localityEndpointsHealth\"\x9e\x02\n" +
	"\x16EndpointHealthResponse\x12_\n" +
	"\x10endpoints_health\x18\x01 \x03(\v2'.envoy.service.health.v3.EndpointHealthB\v\x92ǆ\xd8\x04\x033.0\x18\x01R\x0fendpointsHealth\x12i\n" +
	"\x18cluster_endpoints_health\x18\x02 \x03(\v2/.envoy.service.health.v3.ClusterEndpointsHealthR\x16clusterEndpointsHealth:8\x9aň\x1e3\n" +
	"1envoy.service.discovery.v2.EndpointHealthResponse\"\xd8\x02\n" +
	"*HealthCheckRequestOrEndpointHealthResponse\x12_\n" +
	"\x14health_check_request\x18\x01 \x01(\v2+.envoy.service.health.v3.HealthCheckRequestH\x00R\x12healthCheckRequest\x12k\n" +
	"\x18endpoint_health_response\x18\x02 \x01(\v2/.envoy.service.health.v3.EndpointHealthResponseH\x00R\x16endpointHealthResponse:L\x9aň\x1eG\n" +
	"Eenvoy.service.discovery.v2.HealthCheckRequestOrEndpointHealthResponseB\x0e\n" +
	"\frequest_type\"\xc6\x01\n" +
	"\x11LocalityEndpoints\x12:\n" +
	"\blocality\x18\x01 \x01(\v2\x1e.envoy.config.core.v3.LocalityR\blocality\x12@\n" +
	"\tendpoints\x18\x02 \x03(\v2\".envoy.config.endpoint.v3.EndpointR\tendpoints:3\x9aň\x1e.\n" +
	",envoy.service.discovery.v2.LocalityEndpoints\"\xd5\x03\n" +
	"\x12ClusterHealthCheck\x12!\n" +
	"\fcluster_name\x18\x01 \x01(\tR\vclusterName\x12F\n" +
	"\rhealth_checks\x18\x02 \x03(\v2!.envoy.config.core.v3.HealthCheckR\fhealthChecks\x12Y\n" +
	"\x12locality_endpoints\x18\x03 \x03(\v2*.envoy.service.health.v3.LocalityEndpointsR\x11localityEndpoints\x12o\n" +
	"\x18transport_socket_matches\x18\x04 \x03(\v25.envoy.config.cluster.v3.Cluster.TransportSocketMatchR\x16transportSocketMatches\x12R\n" +
	"\x14upstream_bind_config\x18\x05 \x01(\v2 .envoy.config.core.v3.BindConfigR\x12upstreamBindConfig:4\x9aň\x1e/\n" +
	"-envoy.service.discovery.v2.ClusterHealthCheck\"\xe6\x01\n" +
	"\x14HealthCheckSpecifier\x12_\n" +
	"\x15cluster_health_checks\x18\x01 \x03(\v2+.envoy.service.health.v3.ClusterHealthCheckR\x13clusterHealthChecks\x125\n" +
	"\binterval\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\binterval:6\x9aň\x1e1\n" +
	"/envoy.service.discovery.v2.HealthCheckSpecifier\"\n" +
	"\n" +
	"\bHdsDummy2\xd8\x02\n" +
	"\x16HealthDiscoveryService\x12\x8d\x01\n" +
	"\x11StreamHealthCheck\x12C.envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse\x1a-.envoy.service.health.v3.HealthCheckSpecifier\"\x00(\x010\x01\x12\xad\x01\n" +
	"\x10FetchHealthCheck\x12C.envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse\x1a-.envoy.service.health.v3.HealthCheckSpecifier\"%\x82\xd3\xe4\x93\x02\x1f:\x01*\"\x1a/v3/discovery:health_checkB\x84\x01\xba\x80\xc8\xd1\x06\x02\x10\x02\n" +
	"%io.envoyproxy.envoy.service.health.v3B\bHdsProtoP\x01ZGgithub.com/envoyproxy/go-control-plane/envoy/service/health/v3;healthv3b\x06proto3"

var (
	file_envoy_service_health_v3_hds_proto_rawDescOnce sync.Once
	file_envoy_service_health_v3_hds_proto_rawDescData []byte
)

func file_envoy_service_health_v3_hds_proto_rawDescGZIP() []byte {
	file_envoy_service_health_v3_hds_proto_rawDescOnce.Do(func() {
		file_envoy_service_health_v3_hds_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_envoy_service_health_v3_hds_proto_rawDesc), len(file_envoy_service_health_v3_hds_proto_rawDesc)))
	})
	return file_envoy_service_health_v3_hds_proto_rawDescData
}

var file_envoy_service_health_v3_hds_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_envoy_service_health_v3_hds_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_envoy_service_health_v3_hds_proto_goTypes = []any{
	(Capability_Protocol)(0),                           // 0: envoy.service.health.v3.Capability.Protocol
	(*Capability)(nil),                                 // 1: envoy.service.health.v3.Capability
	(*HealthCheckRequest)(nil),                         // 2: envoy.service.health.v3.HealthCheckRequest
	(*EndpointHealth)(nil),                             // 3: envoy.service.health.v3.EndpointHealth
	(*LocalityEndpointsHealth)(nil),                    // 4: envoy.service.health.v3.LocalityEndpointsHealth
	(*ClusterEndpointsHealth)(nil),                     // 5: envoy.service.health.v3.ClusterEndpointsHealth
	(*EndpointHealthResponse)(nil),                     // 6: envoy.service.health.v3.EndpointHealthResponse
	(*HealthCheckRequestOrEndpointHealthResponse)(nil), // 7: envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse
	(*LocalityEndpoints)(nil),                          // 8: envoy.service.health.v3.LocalityEndpoints
	(*ClusterHealthCheck)(nil),                         // 9: envoy.service.health.v3.ClusterHealthCheck
	(*HealthCheckSpecifier)(nil),                       // 10: envoy.service.health.v3.HealthCheckSpecifier
	(*HdsDummy)(nil),                                   // 11: envoy.service.health.v3.HdsDummy
	(*v3.Node)(nil),                                    // 12: envoy.config.core.v3.Node
	(*v31.Endpoint)(nil),                               // 13: envoy.config.endpoint.v3.Endpoint
	(v3.HealthStatus)(0),                               // 14: envoy.config.core.v3.HealthStatus
	(*structpb.Struct)(nil),                            // 15: google.protobuf.Struct
	(*v3.Locality)(nil),                                // 16: envoy.config.core.v3.Locality
	(*v3.HealthCheck)(nil),                             // 17: envoy.config.core.v3.HealthCheck
	(*v32.Cluster_TransportSocketMatch)(nil),           // 18: envoy.config.cluster.v3.Cluster.TransportSocketMatch
	(*v3.BindConfig)(nil),                              // 19: envoy.config.core.v3.BindConfig
	(*durationpb.Duration)(nil),                        // 20: google.protobuf.Duration
}
var file_envoy_service_health_v3_hds_proto_depIdxs = []int32{
	0,  // 0: envoy.service.health.v3.Capability.health_check_protocols:type_name -> envoy.service.health.v3.Capability.Protocol
	12, // 1: envoy.service.health.v3.HealthCheckRequest.node:type_name -> envoy.config.core.v3.Node
	1,  // 2: envoy.service.health.v3.HealthCheckRequest.capability:type_name -> envoy.service.health.v3.Capability
	13, // 3: envoy.service.health.v3.EndpointHealth.endpoint:type_name -> envoy.config.endpoint.v3.Endpoint
	14, // 4: envoy.service.health.v3.EndpointHealth.health_status:type_name -> envoy.config.core.v3.HealthStatus
	15, // 5: envoy.service.health.v3.EndpointHealth.health_metadata:type_name -> google.protobuf.Struct
	16, // 6: envoy.service.health.v3.LocalityEndpointsHealth.locality:type_name -> envoy.config.core.v3.Locality
	3,  // 7: envoy.service.health.v3.LocalityEndpointsHealth.endpoints_health:type_name -> envoy.service.health.v3.EndpointHealth
	4,  // 8: envoy.service.health.v3.ClusterEndpointsHealth.locality_endpoints_health:type_name -> envoy.service.health.v3.LocalityEndpointsHealth
	3,  // 9: envoy.service.health.v3.EndpointHealthResponse.endpoints_health:type_name -> envoy.service.health.v3.EndpointHealth
	5,  // 10: envoy.service.health.v3.EndpointHealthResponse.cluster_endpoints_health:type_name -> envoy.service.health.v3.ClusterEndpointsHealth
	2,  // 11: envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse.health_check_request:type_name -> envoy.service.health.v3.HealthCheckRequest
	6,  // 12: envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse.endpoint_health_response:type_name -> envoy.service.health.v3.EndpointHealthResponse
	16, // 13: envoy.service.health.v3.LocalityEndpoints.locality:type_name -> envoy.config.core.v3.Locality
	13, // 14: envoy.service.health.v3.LocalityEndpoints.endpoints:type_name -> envoy.config.endpoint.v3.Endpoint
	17, // 15: envoy.service.health.v3.ClusterHealthCheck.health_checks:type_name -> envoy.config.core.v3.HealthCheck
	8,  // 16: envoy.service.health.v3.ClusterHealthCheck.locality_endpoints:type_name -> envoy.service.health.v3.LocalityEndpoints
	18, // 17: envoy.service.health.v3.ClusterHealthCheck.transport_socket_matches:type_name -> envoy.config.cluster.v3.Cluster.TransportSocketMatch
	19, // 18: envoy.service.health.v3.ClusterHealthCheck.upstream_bind_config:type_name -> envoy.config.core.v3.BindConfig
	9,  // 19: envoy.service.health.v3.HealthCheckSpecifier.cluster_health_checks:type_name -> envoy.service.health.v3.ClusterHealthCheck
	20, // 20: envoy.service.health.v3.HealthCheckSpecifier.interval:type_name -> google.protobuf.Duration
	7,  // 21: envoy.service.health.v3.HealthDiscoveryService.StreamHealthCheck:input_type -> envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse
	7,  // 22: envoy.service.health.v3.HealthDiscoveryService.FetchHealthCheck:input_type -> envoy.service.health.v3.HealthCheckRequestOrEndpointHealthResponse
	10, // 23: envoy.service.health.v3.HealthDiscoveryService.StreamHealthCheck:output_type -> envoy.service.health.v3.HealthCheckSpecifier
	10, // 24: envoy.service.health.v3.HealthDiscoveryService.FetchHealthCheck:output_type -> envoy.service.health.v3.HealthCheckSpecifier
	23, // [23:25] is the sub-list for method output_type
	21, // [21:23] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_envoy_service_health_v3_hds_proto_init() }
func file_envoy_service_health_v3_hds_proto_init() {
	if File_envoy_service_health_v3_hds_proto != nil {
		return
	}
	file_envoy_service_health_v3_hds_proto_msgTypes[6].OneofWrappers = []any{
		(*HealthCheckRequestOrEndpointHealthResponse_HealthCheckRequest)(nil),
		(*HealthCheckRequestOrEndpointHealthResponse_EndpointHealthResponse)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_envoy_service_health_v3_hds_proto_rawDesc), len(file_envoy_service_health_v3_hds_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   11,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_envoy_service_health_v3_hds_proto_goTypes,
		DependencyIndexes: file_envoy_service_health_v3_hds_proto_depIdxs,
		EnumInfos:         file_envoy_service_health_v3_hds_proto_enumTypes,
		MessageInfos:      file_envoy_service_health_v3_hds_proto_msgTypes,
	}.Build()
	File_envoy_service_health_v3_hds_proto = out.File
	file_envoy_service_health_v3_hds_proto_goTypes = nil
	file_envoy_service_health_v3_hds_proto_depIdxs = nil
}
