// Code generated by protoc-gen-go. DO NOT EDIT.
// source: envoy/api/v3alpha/cds.proto

package envoy_api_v3alpha

import (
	context "context"
	fmt "fmt"
	cluster "github.com/envoyproxy/go-control-plane/envoy/api/v3alpha/cluster"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v3alpha/core"
	v3alpha "github.com/envoyproxy/go-control-plane/envoy/type/v3alpha"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	duration "github.com/golang/protobuf/ptypes/duration"
	_struct "github.com/golang/protobuf/ptypes/struct"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type Cluster_DiscoveryType int32

const (
	Cluster_STATIC       Cluster_DiscoveryType = 0
	Cluster_STRICT_DNS   Cluster_DiscoveryType = 1
	Cluster_LOGICAL_DNS  Cluster_DiscoveryType = 2
	Cluster_EDS          Cluster_DiscoveryType = 3
	Cluster_ORIGINAL_DST Cluster_DiscoveryType = 4
)

var Cluster_DiscoveryType_name = map[int32]string{
	0: "STATIC",
	1: "STRICT_DNS",
	2: "LOGICAL_DNS",
	3: "EDS",
	4: "ORIGINAL_DST",
}

var Cluster_DiscoveryType_value = map[string]int32{
	"STATIC":       0,
	"STRICT_DNS":   1,
	"LOGICAL_DNS":  2,
	"EDS":          3,
	"ORIGINAL_DST": 4,
}

func (x Cluster_DiscoveryType) String() string {
	return proto.EnumName(Cluster_DiscoveryType_name, int32(x))
}

func (Cluster_DiscoveryType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 0}
}

type Cluster_LbPolicy int32

const (
	Cluster_ROUND_ROBIN                  Cluster_LbPolicy = 0
	Cluster_LEAST_REQUEST                Cluster_LbPolicy = 1
	Cluster_RING_HASH                    Cluster_LbPolicy = 2
	Cluster_RANDOM                       Cluster_LbPolicy = 3
	Cluster_MAGLEV                       Cluster_LbPolicy = 5
	Cluster_CLUSTER_PROVIDED             Cluster_LbPolicy = 6
	Cluster_LOAD_BALANCING_POLICY_CONFIG Cluster_LbPolicy = 7
)

var Cluster_LbPolicy_name = map[int32]string{
	0: "ROUND_ROBIN",
	1: "LEAST_REQUEST",
	2: "RING_HASH",
	3: "RANDOM",
	5: "MAGLEV",
	6: "CLUSTER_PROVIDED",
	7: "LOAD_BALANCING_POLICY_CONFIG",
}

var Cluster_LbPolicy_value = map[string]int32{
	"ROUND_ROBIN":                  0,
	"LEAST_REQUEST":                1,
	"RING_HASH":                    2,
	"RANDOM":                       3,
	"MAGLEV":                       5,
	"CLUSTER_PROVIDED":             6,
	"LOAD_BALANCING_POLICY_CONFIG": 7,
}

func (x Cluster_LbPolicy) String() string {
	return proto.EnumName(Cluster_LbPolicy_name, int32(x))
}

func (Cluster_LbPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 1}
}

type Cluster_DnsLookupFamily int32

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

var Cluster_DnsLookupFamily_name = map[int32]string{
	0: "AUTO",
	1: "V4_ONLY",
	2: "V6_ONLY",
}

var Cluster_DnsLookupFamily_value = map[string]int32{
	"AUTO":    0,
	"V4_ONLY": 1,
	"V6_ONLY": 2,
}

func (x Cluster_DnsLookupFamily) String() string {
	return proto.EnumName(Cluster_DnsLookupFamily_name, int32(x))
}

func (Cluster_DnsLookupFamily) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 2}
}

type Cluster_ClusterProtocolSelection int32

const (
	Cluster_USE_CONFIGURED_PROTOCOL Cluster_ClusterProtocolSelection = 0
	Cluster_USE_DOWNSTREAM_PROTOCOL Cluster_ClusterProtocolSelection = 1
)

var Cluster_ClusterProtocolSelection_name = map[int32]string{
	0: "USE_CONFIGURED_PROTOCOL",
	1: "USE_DOWNSTREAM_PROTOCOL",
}

var Cluster_ClusterProtocolSelection_value = map[string]int32{
	"USE_CONFIGURED_PROTOCOL": 0,
	"USE_DOWNSTREAM_PROTOCOL": 1,
}

func (x Cluster_ClusterProtocolSelection) String() string {
	return proto.EnumName(Cluster_ClusterProtocolSelection_name, int32(x))
}

func (Cluster_ClusterProtocolSelection) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 3}
}

type Cluster_LbSubsetConfig_LbSubsetFallbackPolicy int32

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

var Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_name = map[int32]string{
	0: "NO_FALLBACK",
	1: "ANY_ENDPOINT",
	2: "DEFAULT_SUBSET",
}

var Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_value = map[string]int32{
	"NO_FALLBACK":    0,
	"ANY_ENDPOINT":   1,
	"DEFAULT_SUBSET": 2,
}

func (x Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) String() string {
	return proto.EnumName(Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_name, int32(x))
}

func (Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 3, 0}
}

type Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy int32

const (
	Cluster_LbSubsetConfig_LbSubsetSelector_NOT_DEFINED    Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 0
	Cluster_LbSubsetConfig_LbSubsetSelector_NO_FALLBACK    Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 1
	Cluster_LbSubsetConfig_LbSubsetSelector_ANY_ENDPOINT   Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 2
	Cluster_LbSubsetConfig_LbSubsetSelector_DEFAULT_SUBSET Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 3
)

var Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_name = map[int32]string{
	0: "NOT_DEFINED",
	1: "NO_FALLBACK",
	2: "ANY_ENDPOINT",
	3: "DEFAULT_SUBSET",
}

var Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_value = map[string]int32{
	"NOT_DEFINED":    0,
	"NO_FALLBACK":    1,
	"ANY_ENDPOINT":   2,
	"DEFAULT_SUBSET": 3,
}

func (x Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) String() string {
	return proto.EnumName(Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_name, int32(x))
}

func (Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 3, 0, 0}
}

type Cluster_RingHashLbConfig_HashFunction int32

const (
	Cluster_RingHashLbConfig_XX_HASH       Cluster_RingHashLbConfig_HashFunction = 0
	Cluster_RingHashLbConfig_MURMUR_HASH_2 Cluster_RingHashLbConfig_HashFunction = 1
)

var Cluster_RingHashLbConfig_HashFunction_name = map[int32]string{
	0: "XX_HASH",
	1: "MURMUR_HASH_2",
}

var Cluster_RingHashLbConfig_HashFunction_value = map[string]int32{
	"XX_HASH":       0,
	"MURMUR_HASH_2": 1,
}

func (x Cluster_RingHashLbConfig_HashFunction) String() string {
	return proto.EnumName(Cluster_RingHashLbConfig_HashFunction_name, int32(x))
}

func (Cluster_RingHashLbConfig_HashFunction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 5, 0}
}

type Cluster struct {
	TransportSocketMatches []*Cluster_TransportSocketMatch `protobuf:"bytes,43,rep,name=transport_socket_matches,json=transportSocketMatches,proto3" json:"transport_socket_matches,omitempty"`
	Name                   string                          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	AltStatName            string                          `protobuf:"bytes,28,opt,name=alt_stat_name,json=altStatName,proto3" json:"alt_stat_name,omitempty"`
	// Types that are valid to be assigned to ClusterDiscoveryType:
	//	*Cluster_Type
	//	*Cluster_ClusterType
	ClusterDiscoveryType          isCluster_ClusterDiscoveryType `protobuf_oneof:"cluster_discovery_type"`
	EdsClusterConfig              *Cluster_EdsClusterConfig      `protobuf:"bytes,3,opt,name=eds_cluster_config,json=edsClusterConfig,proto3" json:"eds_cluster_config,omitempty"`
	ConnectTimeout                *duration.Duration             `protobuf:"bytes,4,opt,name=connect_timeout,json=connectTimeout,proto3" json:"connect_timeout,omitempty"`
	PerConnectionBufferLimitBytes *wrappers.UInt32Value          `protobuf:"bytes,5,opt,name=per_connection_buffer_limit_bytes,json=perConnectionBufferLimitBytes,proto3" json:"per_connection_buffer_limit_bytes,omitempty"`
	LbPolicy                      Cluster_LbPolicy               `protobuf:"varint,6,opt,name=lb_policy,json=lbPolicy,proto3,enum=envoy.api.v3alpha.Cluster_LbPolicy" json:"lb_policy,omitempty"`
	Hosts                         []*core.Address                `protobuf:"bytes,7,rep,name=hosts,proto3" json:"hosts,omitempty"`
	LoadAssignment                *ClusterLoadAssignment         `protobuf:"bytes,33,opt,name=load_assignment,json=loadAssignment,proto3" json:"load_assignment,omitempty"`
	HealthChecks                  []*core.HealthCheck            `protobuf:"bytes,8,rep,name=health_checks,json=healthChecks,proto3" json:"health_checks,omitempty"`
	MaxRequestsPerConnection      *wrappers.UInt32Value          `protobuf:"bytes,9,opt,name=max_requests_per_connection,json=maxRequestsPerConnection,proto3" json:"max_requests_per_connection,omitempty"`
	CircuitBreakers               *cluster.CircuitBreakers       `protobuf:"bytes,10,opt,name=circuit_breakers,json=circuitBreakers,proto3" json:"circuit_breakers,omitempty"`
	CommonHttpProtocolOptions     *core.HttpProtocolOptions      `protobuf:"bytes,29,opt,name=common_http_protocol_options,json=commonHttpProtocolOptions,proto3" json:"common_http_protocol_options,omitempty"`
	HttpProtocolOptions           *core.Http1ProtocolOptions     `protobuf:"bytes,13,opt,name=http_protocol_options,json=httpProtocolOptions,proto3" json:"http_protocol_options,omitempty"`
	Http2ProtocolOptions          *core.Http2ProtocolOptions     `protobuf:"bytes,14,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	TypedExtensionProtocolOptions map[string]*any.Any            `protobuf:"bytes,36,rep,name=typed_extension_protocol_options,json=typedExtensionProtocolOptions,proto3" json:"typed_extension_protocol_options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	DnsRefreshRate                *duration.Duration             `protobuf:"bytes,16,opt,name=dns_refresh_rate,json=dnsRefreshRate,proto3" json:"dns_refresh_rate,omitempty"`
	DnsFailureRefreshRate         *Cluster_RefreshRate           `protobuf:"bytes,44,opt,name=dns_failure_refresh_rate,json=dnsFailureRefreshRate,proto3" json:"dns_failure_refresh_rate,omitempty"`
	RespectDnsTtl                 bool                           `protobuf:"varint,39,opt,name=respect_dns_ttl,json=respectDnsTtl,proto3" json:"respect_dns_ttl,omitempty"`
	DnsLookupFamily               Cluster_DnsLookupFamily        `protobuf:"varint,17,opt,name=dns_lookup_family,json=dnsLookupFamily,proto3,enum=envoy.api.v3alpha.Cluster_DnsLookupFamily" json:"dns_lookup_family,omitempty"`
	DnsResolvers                  []*core.Address                `protobuf:"bytes,18,rep,name=dns_resolvers,json=dnsResolvers,proto3" json:"dns_resolvers,omitempty"`
	OutlierDetection              *cluster.OutlierDetection      `protobuf:"bytes,19,opt,name=outlier_detection,json=outlierDetection,proto3" json:"outlier_detection,omitempty"`
	CleanupInterval               *duration.Duration             `protobuf:"bytes,20,opt,name=cleanup_interval,json=cleanupInterval,proto3" json:"cleanup_interval,omitempty"`
	UpstreamBindConfig            *core.BindConfig               `protobuf:"bytes,21,opt,name=upstream_bind_config,json=upstreamBindConfig,proto3" json:"upstream_bind_config,omitempty"`
	LbSubsetConfig                *Cluster_LbSubsetConfig        `protobuf:"bytes,22,opt,name=lb_subset_config,json=lbSubsetConfig,proto3" json:"lb_subset_config,omitempty"`
	// Types that are valid to be assigned to LbConfig:
	//	*Cluster_RingHashLbConfig_
	//	*Cluster_OriginalDstLbConfig_
	//	*Cluster_LeastRequestLbConfig_
	LbConfig                            isCluster_LbConfig               `protobuf_oneof:"lb_config"`
	CommonLbConfig                      *Cluster_CommonLbConfig          `protobuf:"bytes,27,opt,name=common_lb_config,json=commonLbConfig,proto3" json:"common_lb_config,omitempty"`
	TransportSocket                     *core.TransportSocket            `protobuf:"bytes,24,opt,name=transport_socket,json=transportSocket,proto3" json:"transport_socket,omitempty"`
	Metadata                            *core.Metadata                   `protobuf:"bytes,25,opt,name=metadata,proto3" json:"metadata,omitempty"`
	ProtocolSelection                   Cluster_ClusterProtocolSelection `protobuf:"varint,26,opt,name=protocol_selection,json=protocolSelection,proto3,enum=envoy.api.v3alpha.Cluster_ClusterProtocolSelection" json:"protocol_selection,omitempty"`
	UpstreamConnectionOptions           *UpstreamConnectionOptions       `protobuf:"bytes,30,opt,name=upstream_connection_options,json=upstreamConnectionOptions,proto3" json:"upstream_connection_options,omitempty"`
	CloseConnectionsOnHostHealthFailure bool                             `protobuf:"varint,31,opt,name=close_connections_on_host_health_failure,json=closeConnectionsOnHostHealthFailure,proto3" json:"close_connections_on_host_health_failure,omitempty"`
	DrainConnectionsOnHostRemoval       bool                             `protobuf:"varint,32,opt,name=drain_connections_on_host_removal,json=drainConnectionsOnHostRemoval,proto3" json:"drain_connections_on_host_removal,omitempty"`
	Filters                             []*cluster.Filter                `protobuf:"bytes,40,rep,name=filters,proto3" json:"filters,omitempty"`
	LoadBalancingPolicy                 *LoadBalancingPolicy             `protobuf:"bytes,41,opt,name=load_balancing_policy,json=loadBalancingPolicy,proto3" json:"load_balancing_policy,omitempty"`
	LrsServer                           *core.ConfigSource               `protobuf:"bytes,42,opt,name=lrs_server,json=lrsServer,proto3" json:"lrs_server,omitempty"`
	XXX_NoUnkeyedLiteral                struct{}                         `json:"-"`
	XXX_unrecognized                    []byte                           `json:"-"`
	XXX_sizecache                       int32                            `json:"-"`
}

func (m *Cluster) Reset()         { *m = Cluster{} }
func (m *Cluster) String() string { return proto.CompactTextString(m) }
func (*Cluster) ProtoMessage()    {}
func (*Cluster) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0}
}

func (m *Cluster) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster.Unmarshal(m, b)
}
func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
}
func (m *Cluster) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster.Merge(m, src)
}
func (m *Cluster) XXX_Size() int {
	return xxx_messageInfo_Cluster.Size(m)
}
func (m *Cluster) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster proto.InternalMessageInfo

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

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

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

type isCluster_ClusterDiscoveryType interface {
	isCluster_ClusterDiscoveryType()
}

type Cluster_Type struct {
	Type Cluster_DiscoveryType `protobuf:"varint,2,opt,name=type,proto3,enum=envoy.api.v3alpha.Cluster_DiscoveryType,oneof"`
}

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

func (*Cluster_Type) isCluster_ClusterDiscoveryType() {}

func (*Cluster_ClusterType) isCluster_ClusterDiscoveryType() {}

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

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

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

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

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

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

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

func (m *Cluster) GetHosts() []*core.Address {
	if m != nil {
		return m.Hosts
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type isCluster_LbConfig interface {
	isCluster_LbConfig()
}

type Cluster_RingHashLbConfig_ struct {
	RingHashLbConfig *Cluster_RingHashLbConfig `protobuf:"bytes,23,opt,name=ring_hash_lb_config,json=ringHashLbConfig,proto3,oneof"`
}

type Cluster_OriginalDstLbConfig_ struct {
	OriginalDstLbConfig *Cluster_OriginalDstLbConfig `protobuf:"bytes,34,opt,name=original_dst_lb_config,json=originalDstLbConfig,proto3,oneof"`
}

type Cluster_LeastRequestLbConfig_ struct {
	LeastRequestLbConfig *Cluster_LeastRequestLbConfig `protobuf:"bytes,37,opt,name=least_request_lb_config,json=leastRequestLbConfig,proto3,oneof"`
}

func (*Cluster_RingHashLbConfig_) isCluster_LbConfig() {}

func (*Cluster_OriginalDstLbConfig_) isCluster_LbConfig() {}

func (*Cluster_LeastRequestLbConfig_) isCluster_LbConfig() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Cluster) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Cluster_Type)(nil),
		(*Cluster_ClusterType)(nil),
		(*Cluster_RingHashLbConfig_)(nil),
		(*Cluster_OriginalDstLbConfig_)(nil),
		(*Cluster_LeastRequestLbConfig_)(nil),
	}
}

type Cluster_TransportSocketMatch struct {
	Name                 string                `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Match                *_struct.Struct       `protobuf:"bytes,2,opt,name=match,proto3" json:"match,omitempty"`
	TransportSocket      *core.TransportSocket `protobuf:"bytes,3,opt,name=transport_socket,json=transportSocket,proto3" json:"transport_socket,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *Cluster_TransportSocketMatch) Reset()         { *m = Cluster_TransportSocketMatch{} }
func (m *Cluster_TransportSocketMatch) String() string { return proto.CompactTextString(m) }
func (*Cluster_TransportSocketMatch) ProtoMessage()    {}
func (*Cluster_TransportSocketMatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 0}
}

func (m *Cluster_TransportSocketMatch) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_TransportSocketMatch.Unmarshal(m, b)
}
func (m *Cluster_TransportSocketMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_TransportSocketMatch.Marshal(b, m, deterministic)
}
func (m *Cluster_TransportSocketMatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_TransportSocketMatch.Merge(m, src)
}
func (m *Cluster_TransportSocketMatch) XXX_Size() int {
	return xxx_messageInfo_Cluster_TransportSocketMatch.Size(m)
}
func (m *Cluster_TransportSocketMatch) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_TransportSocketMatch.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_TransportSocketMatch proto.InternalMessageInfo

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

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

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

type Cluster_CustomClusterType struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	TypedConfig          *any.Any `protobuf:"bytes,2,opt,name=typed_config,json=typedConfig,proto3" json:"typed_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Cluster_CustomClusterType) Reset()         { *m = Cluster_CustomClusterType{} }
func (m *Cluster_CustomClusterType) String() string { return proto.CompactTextString(m) }
func (*Cluster_CustomClusterType) ProtoMessage()    {}
func (*Cluster_CustomClusterType) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 1}
}

func (m *Cluster_CustomClusterType) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_CustomClusterType.Unmarshal(m, b)
}
func (m *Cluster_CustomClusterType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_CustomClusterType.Marshal(b, m, deterministic)
}
func (m *Cluster_CustomClusterType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CustomClusterType.Merge(m, src)
}
func (m *Cluster_CustomClusterType) XXX_Size() int {
	return xxx_messageInfo_Cluster_CustomClusterType.Size(m)
}
func (m *Cluster_CustomClusterType) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_CustomClusterType.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_CustomClusterType proto.InternalMessageInfo

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

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

type Cluster_EdsClusterConfig struct {
	EdsConfig            *core.ConfigSource `protobuf:"bytes,1,opt,name=eds_config,json=edsConfig,proto3" json:"eds_config,omitempty"`
	ServiceName          string             `protobuf:"bytes,2,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Cluster_EdsClusterConfig) Reset()         { *m = Cluster_EdsClusterConfig{} }
func (m *Cluster_EdsClusterConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_EdsClusterConfig) ProtoMessage()    {}
func (*Cluster_EdsClusterConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 2}
}

func (m *Cluster_EdsClusterConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_EdsClusterConfig.Unmarshal(m, b)
}
func (m *Cluster_EdsClusterConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_EdsClusterConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_EdsClusterConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_EdsClusterConfig.Merge(m, src)
}
func (m *Cluster_EdsClusterConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_EdsClusterConfig.Size(m)
}
func (m *Cluster_EdsClusterConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_EdsClusterConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_EdsClusterConfig proto.InternalMessageInfo

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

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

type Cluster_LbSubsetConfig struct {
	FallbackPolicy       Cluster_LbSubsetConfig_LbSubsetFallbackPolicy `protobuf:"varint,1,opt,name=fallback_policy,json=fallbackPolicy,proto3,enum=envoy.api.v3alpha.Cluster_LbSubsetConfig_LbSubsetFallbackPolicy" json:"fallback_policy,omitempty"`
	DefaultSubset        *_struct.Struct                               `protobuf:"bytes,2,opt,name=default_subset,json=defaultSubset,proto3" json:"default_subset,omitempty"`
	SubsetSelectors      []*Cluster_LbSubsetConfig_LbSubsetSelector    `protobuf:"bytes,3,rep,name=subset_selectors,json=subsetSelectors,proto3" json:"subset_selectors,omitempty"`
	LocalityWeightAware  bool                                          `protobuf:"varint,4,opt,name=locality_weight_aware,json=localityWeightAware,proto3" json:"locality_weight_aware,omitempty"`
	ScaleLocalityWeight  bool                                          `protobuf:"varint,5,opt,name=scale_locality_weight,json=scaleLocalityWeight,proto3" json:"scale_locality_weight,omitempty"`
	PanicModeAny         bool                                          `protobuf:"varint,6,opt,name=panic_mode_any,json=panicModeAny,proto3" json:"panic_mode_any,omitempty"`
	ListAsAny            bool                                          `protobuf:"varint,7,opt,name=list_as_any,json=listAsAny,proto3" json:"list_as_any,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                      `json:"-"`
	XXX_unrecognized     []byte                                        `json:"-"`
	XXX_sizecache        int32                                         `json:"-"`
}

func (m *Cluster_LbSubsetConfig) Reset()         { *m = Cluster_LbSubsetConfig{} }
func (m *Cluster_LbSubsetConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_LbSubsetConfig) ProtoMessage()    {}
func (*Cluster_LbSubsetConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 3}
}

func (m *Cluster_LbSubsetConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_LbSubsetConfig.Unmarshal(m, b)
}
func (m *Cluster_LbSubsetConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_LbSubsetConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_LbSubsetConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_LbSubsetConfig.Merge(m, src)
}
func (m *Cluster_LbSubsetConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_LbSubsetConfig.Size(m)
}
func (m *Cluster_LbSubsetConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_LbSubsetConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_LbSubsetConfig proto.InternalMessageInfo

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

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

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

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

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

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

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

type Cluster_LbSubsetConfig_LbSubsetSelector struct {
	Keys                 []string                                                               `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
	FallbackPolicy       Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy `protobuf:"varint,2,opt,name=fallback_policy,json=fallbackPolicy,proto3,enum=envoy.api.v3alpha.Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy" json:"fallback_policy,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                                               `json:"-"`
	XXX_unrecognized     []byte                                                                 `json:"-"`
	XXX_sizecache        int32                                                                  `json:"-"`
}

func (m *Cluster_LbSubsetConfig_LbSubsetSelector) Reset() {
	*m = Cluster_LbSubsetConfig_LbSubsetSelector{}
}
func (m *Cluster_LbSubsetConfig_LbSubsetSelector) String() string { return proto.CompactTextString(m) }
func (*Cluster_LbSubsetConfig_LbSubsetSelector) ProtoMessage()    {}
func (*Cluster_LbSubsetConfig_LbSubsetSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 3, 0}
}

func (m *Cluster_LbSubsetConfig_LbSubsetSelector) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector.Unmarshal(m, b)
}
func (m *Cluster_LbSubsetConfig_LbSubsetSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector.Marshal(b, m, deterministic)
}
func (m *Cluster_LbSubsetConfig_LbSubsetSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector.Merge(m, src)
}
func (m *Cluster_LbSubsetConfig_LbSubsetSelector) XXX_Size() int {
	return xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector.Size(m)
}
func (m *Cluster_LbSubsetConfig_LbSubsetSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector proto.InternalMessageInfo

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

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

type Cluster_LeastRequestLbConfig struct {
	ChoiceCount          *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=choice_count,json=choiceCount,proto3" json:"choice_count,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *Cluster_LeastRequestLbConfig) Reset()         { *m = Cluster_LeastRequestLbConfig{} }
func (m *Cluster_LeastRequestLbConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_LeastRequestLbConfig) ProtoMessage()    {}
func (*Cluster_LeastRequestLbConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 4}
}

func (m *Cluster_LeastRequestLbConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_LeastRequestLbConfig.Unmarshal(m, b)
}
func (m *Cluster_LeastRequestLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_LeastRequestLbConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_LeastRequestLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_LeastRequestLbConfig.Merge(m, src)
}
func (m *Cluster_LeastRequestLbConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_LeastRequestLbConfig.Size(m)
}
func (m *Cluster_LeastRequestLbConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_LeastRequestLbConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_LeastRequestLbConfig proto.InternalMessageInfo

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

type Cluster_RingHashLbConfig struct {
	MinimumRingSize      *wrappers.UInt64Value                 `protobuf:"bytes,1,opt,name=minimum_ring_size,json=minimumRingSize,proto3" json:"minimum_ring_size,omitempty"`
	HashFunction         Cluster_RingHashLbConfig_HashFunction `protobuf:"varint,3,opt,name=hash_function,json=hashFunction,proto3,enum=envoy.api.v3alpha.Cluster_RingHashLbConfig_HashFunction" json:"hash_function,omitempty"`
	MaximumRingSize      *wrappers.UInt64Value                 `protobuf:"bytes,4,opt,name=maximum_ring_size,json=maximumRingSize,proto3" json:"maximum_ring_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *Cluster_RingHashLbConfig) Reset()         { *m = Cluster_RingHashLbConfig{} }
func (m *Cluster_RingHashLbConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_RingHashLbConfig) ProtoMessage()    {}
func (*Cluster_RingHashLbConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 5}
}

func (m *Cluster_RingHashLbConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_RingHashLbConfig.Unmarshal(m, b)
}
func (m *Cluster_RingHashLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_RingHashLbConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_RingHashLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_RingHashLbConfig.Merge(m, src)
}
func (m *Cluster_RingHashLbConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_RingHashLbConfig.Size(m)
}
func (m *Cluster_RingHashLbConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_RingHashLbConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_RingHashLbConfig proto.InternalMessageInfo

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

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

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

type Cluster_OriginalDstLbConfig struct {
	UseHttpHeader        bool     `protobuf:"varint,1,opt,name=use_http_header,json=useHttpHeader,proto3" json:"use_http_header,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Cluster_OriginalDstLbConfig) Reset()         { *m = Cluster_OriginalDstLbConfig{} }
func (m *Cluster_OriginalDstLbConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_OriginalDstLbConfig) ProtoMessage()    {}
func (*Cluster_OriginalDstLbConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 6}
}

func (m *Cluster_OriginalDstLbConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_OriginalDstLbConfig.Unmarshal(m, b)
}
func (m *Cluster_OriginalDstLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_OriginalDstLbConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_OriginalDstLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_OriginalDstLbConfig.Merge(m, src)
}
func (m *Cluster_OriginalDstLbConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_OriginalDstLbConfig.Size(m)
}
func (m *Cluster_OriginalDstLbConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_OriginalDstLbConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_OriginalDstLbConfig proto.InternalMessageInfo

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

type Cluster_CommonLbConfig struct {
	HealthyPanicThreshold *v3alpha.Percent `protobuf:"bytes,1,opt,name=healthy_panic_threshold,json=healthyPanicThreshold,proto3" json:"healthy_panic_threshold,omitempty"`
	// Types that are valid to be assigned to LocalityConfigSpecifier:
	//	*Cluster_CommonLbConfig_ZoneAwareLbConfig_
	//	*Cluster_CommonLbConfig_LocalityWeightedLbConfig_
	LocalityConfigSpecifier         isCluster_CommonLbConfig_LocalityConfigSpecifier `protobuf_oneof:"locality_config_specifier"`
	UpdateMergeWindow               *duration.Duration                               `protobuf:"bytes,4,opt,name=update_merge_window,json=updateMergeWindow,proto3" json:"update_merge_window,omitempty"`
	IgnoreNewHostsUntilFirstHc      bool                                             `protobuf:"varint,5,opt,name=ignore_new_hosts_until_first_hc,json=ignoreNewHostsUntilFirstHc,proto3" json:"ignore_new_hosts_until_first_hc,omitempty"`
	CloseConnectionsOnHostSetChange bool                                             `protobuf:"varint,6,opt,name=close_connections_on_host_set_change,json=closeConnectionsOnHostSetChange,proto3" json:"close_connections_on_host_set_change,omitempty"`
	XXX_NoUnkeyedLiteral            struct{}                                         `json:"-"`
	XXX_unrecognized                []byte                                           `json:"-"`
	XXX_sizecache                   int32                                            `json:"-"`
}

func (m *Cluster_CommonLbConfig) Reset()         { *m = Cluster_CommonLbConfig{} }
func (m *Cluster_CommonLbConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_CommonLbConfig) ProtoMessage()    {}
func (*Cluster_CommonLbConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 7}
}

func (m *Cluster_CommonLbConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_CommonLbConfig.Unmarshal(m, b)
}
func (m *Cluster_CommonLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_CommonLbConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_CommonLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CommonLbConfig.Merge(m, src)
}
func (m *Cluster_CommonLbConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_CommonLbConfig.Size(m)
}
func (m *Cluster_CommonLbConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_CommonLbConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_CommonLbConfig proto.InternalMessageInfo

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

type isCluster_CommonLbConfig_LocalityConfigSpecifier interface {
	isCluster_CommonLbConfig_LocalityConfigSpecifier()
}

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

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

func (*Cluster_CommonLbConfig_ZoneAwareLbConfig_) isCluster_CommonLbConfig_LocalityConfigSpecifier() {}

func (*Cluster_CommonLbConfig_LocalityWeightedLbConfig_) isCluster_CommonLbConfig_LocalityConfigSpecifier() {
}

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

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

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

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

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Cluster_CommonLbConfig) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Cluster_CommonLbConfig_ZoneAwareLbConfig_)(nil),
		(*Cluster_CommonLbConfig_LocalityWeightedLbConfig_)(nil),
	}
}

type Cluster_CommonLbConfig_ZoneAwareLbConfig struct {
	RoutingEnabled       *v3alpha.Percent      `protobuf:"bytes,1,opt,name=routing_enabled,json=routingEnabled,proto3" json:"routing_enabled,omitempty"`
	MinClusterSize       *wrappers.UInt64Value `protobuf:"bytes,2,opt,name=min_cluster_size,json=minClusterSize,proto3" json:"min_cluster_size,omitempty"`
	FailTrafficOnPanic   bool                  `protobuf:"varint,3,opt,name=fail_traffic_on_panic,json=failTrafficOnPanic,proto3" json:"fail_traffic_on_panic,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) Reset() {
	*m = Cluster_CommonLbConfig_ZoneAwareLbConfig{}
}
func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) String() string { return proto.CompactTextString(m) }
func (*Cluster_CommonLbConfig_ZoneAwareLbConfig) ProtoMessage()    {}
func (*Cluster_CommonLbConfig_ZoneAwareLbConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 7, 0}
}

func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig.Unmarshal(m, b)
}
func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig.Merge(m, src)
}
func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig.Size(m)
}
func (m *Cluster_CommonLbConfig_ZoneAwareLbConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig proto.InternalMessageInfo

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

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

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

type Cluster_CommonLbConfig_LocalityWeightedLbConfig struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) Reset() {
	*m = Cluster_CommonLbConfig_LocalityWeightedLbConfig{}
}
func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) String() string {
	return proto.CompactTextString(m)
}
func (*Cluster_CommonLbConfig_LocalityWeightedLbConfig) ProtoMessage() {}
func (*Cluster_CommonLbConfig_LocalityWeightedLbConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 7, 1}
}

func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig.Unmarshal(m, b)
}
func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig.Marshal(b, m, deterministic)
}
func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig.Merge(m, src)
}
func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) XXX_Size() int {
	return xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig.Size(m)
}
func (m *Cluster_CommonLbConfig_LocalityWeightedLbConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig proto.InternalMessageInfo

type Cluster_RefreshRate struct {
	BaseInterval         *duration.Duration `protobuf:"bytes,1,opt,name=base_interval,json=baseInterval,proto3" json:"base_interval,omitempty"`
	MaxInterval          *duration.Duration `protobuf:"bytes,2,opt,name=max_interval,json=maxInterval,proto3" json:"max_interval,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Cluster_RefreshRate) Reset()         { *m = Cluster_RefreshRate{} }
func (m *Cluster_RefreshRate) String() string { return proto.CompactTextString(m) }
func (*Cluster_RefreshRate) ProtoMessage()    {}
func (*Cluster_RefreshRate) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{0, 8}
}

func (m *Cluster_RefreshRate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Cluster_RefreshRate.Unmarshal(m, b)
}
func (m *Cluster_RefreshRate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Cluster_RefreshRate.Marshal(b, m, deterministic)
}
func (m *Cluster_RefreshRate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_RefreshRate.Merge(m, src)
}
func (m *Cluster_RefreshRate) XXX_Size() int {
	return xxx_messageInfo_Cluster_RefreshRate.Size(m)
}
func (m *Cluster_RefreshRate) XXX_DiscardUnknown() {
	xxx_messageInfo_Cluster_RefreshRate.DiscardUnknown(m)
}

var xxx_messageInfo_Cluster_RefreshRate proto.InternalMessageInfo

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

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

type LoadBalancingPolicy struct {
	Policies             []*LoadBalancingPolicy_Policy `protobuf:"bytes,1,rep,name=policies,proto3" json:"policies,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *LoadBalancingPolicy) Reset()         { *m = LoadBalancingPolicy{} }
func (m *LoadBalancingPolicy) String() string { return proto.CompactTextString(m) }
func (*LoadBalancingPolicy) ProtoMessage()    {}
func (*LoadBalancingPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{1}
}

func (m *LoadBalancingPolicy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancingPolicy.Unmarshal(m, b)
}
func (m *LoadBalancingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancingPolicy.Marshal(b, m, deterministic)
}
func (m *LoadBalancingPolicy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancingPolicy.Merge(m, src)
}
func (m *LoadBalancingPolicy) XXX_Size() int {
	return xxx_messageInfo_LoadBalancingPolicy.Size(m)
}
func (m *LoadBalancingPolicy) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancingPolicy.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancingPolicy proto.InternalMessageInfo

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

type LoadBalancingPolicy_Policy struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	TypedConfig          *any.Any `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3" json:"typed_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LoadBalancingPolicy_Policy) Reset()         { *m = LoadBalancingPolicy_Policy{} }
func (m *LoadBalancingPolicy_Policy) String() string { return proto.CompactTextString(m) }
func (*LoadBalancingPolicy_Policy) ProtoMessage()    {}
func (*LoadBalancingPolicy_Policy) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{1, 0}
}

func (m *LoadBalancingPolicy_Policy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancingPolicy_Policy.Unmarshal(m, b)
}
func (m *LoadBalancingPolicy_Policy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancingPolicy_Policy.Marshal(b, m, deterministic)
}
func (m *LoadBalancingPolicy_Policy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancingPolicy_Policy.Merge(m, src)
}
func (m *LoadBalancingPolicy_Policy) XXX_Size() int {
	return xxx_messageInfo_LoadBalancingPolicy_Policy.Size(m)
}
func (m *LoadBalancingPolicy_Policy) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancingPolicy_Policy.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancingPolicy_Policy proto.InternalMessageInfo

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

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

type UpstreamBindConfig struct {
	SourceAddress        *core.Address `protobuf:"bytes,1,opt,name=source_address,json=sourceAddress,proto3" json:"source_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *UpstreamBindConfig) Reset()         { *m = UpstreamBindConfig{} }
func (m *UpstreamBindConfig) String() string { return proto.CompactTextString(m) }
func (*UpstreamBindConfig) ProtoMessage()    {}
func (*UpstreamBindConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{2}
}

func (m *UpstreamBindConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpstreamBindConfig.Unmarshal(m, b)
}
func (m *UpstreamBindConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpstreamBindConfig.Marshal(b, m, deterministic)
}
func (m *UpstreamBindConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpstreamBindConfig.Merge(m, src)
}
func (m *UpstreamBindConfig) XXX_Size() int {
	return xxx_messageInfo_UpstreamBindConfig.Size(m)
}
func (m *UpstreamBindConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_UpstreamBindConfig.DiscardUnknown(m)
}

var xxx_messageInfo_UpstreamBindConfig proto.InternalMessageInfo

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

type UpstreamConnectionOptions struct {
	TcpKeepalive         *core.TcpKeepalive `protobuf:"bytes,1,opt,name=tcp_keepalive,json=tcpKeepalive,proto3" json:"tcp_keepalive,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *UpstreamConnectionOptions) Reset()         { *m = UpstreamConnectionOptions{} }
func (m *UpstreamConnectionOptions) String() string { return proto.CompactTextString(m) }
func (*UpstreamConnectionOptions) ProtoMessage()    {}
func (*UpstreamConnectionOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_1145bef7abd8c457, []int{3}
}

func (m *UpstreamConnectionOptions) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpstreamConnectionOptions.Unmarshal(m, b)
}
func (m *UpstreamConnectionOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpstreamConnectionOptions.Marshal(b, m, deterministic)
}
func (m *UpstreamConnectionOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpstreamConnectionOptions.Merge(m, src)
}
func (m *UpstreamConnectionOptions) XXX_Size() int {
	return xxx_messageInfo_UpstreamConnectionOptions.Size(m)
}
func (m *UpstreamConnectionOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_UpstreamConnectionOptions.DiscardUnknown(m)
}

var xxx_messageInfo_UpstreamConnectionOptions proto.InternalMessageInfo

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

func init() {
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_DiscoveryType", Cluster_DiscoveryType_name, Cluster_DiscoveryType_value)
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_LbPolicy", Cluster_LbPolicy_name, Cluster_LbPolicy_value)
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_DnsLookupFamily", Cluster_DnsLookupFamily_name, Cluster_DnsLookupFamily_value)
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_ClusterProtocolSelection", Cluster_ClusterProtocolSelection_name, Cluster_ClusterProtocolSelection_value)
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_LbSubsetConfig_LbSubsetFallbackPolicy", Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_name, Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_value)
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy", Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_name, Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_value)
	proto.RegisterEnum("envoy.api.v3alpha.Cluster_RingHashLbConfig_HashFunction", Cluster_RingHashLbConfig_HashFunction_name, Cluster_RingHashLbConfig_HashFunction_value)
	proto.RegisterType((*Cluster)(nil), "envoy.api.v3alpha.Cluster")
	proto.RegisterMapType((map[string]*any.Any)(nil), "envoy.api.v3alpha.Cluster.TypedExtensionProtocolOptionsEntry")
	proto.RegisterType((*Cluster_TransportSocketMatch)(nil), "envoy.api.v3alpha.Cluster.TransportSocketMatch")
	proto.RegisterType((*Cluster_CustomClusterType)(nil), "envoy.api.v3alpha.Cluster.CustomClusterType")
	proto.RegisterType((*Cluster_EdsClusterConfig)(nil), "envoy.api.v3alpha.Cluster.EdsClusterConfig")
	proto.RegisterType((*Cluster_LbSubsetConfig)(nil), "envoy.api.v3alpha.Cluster.LbSubsetConfig")
	proto.RegisterType((*Cluster_LbSubsetConfig_LbSubsetSelector)(nil), "envoy.api.v3alpha.Cluster.LbSubsetConfig.LbSubsetSelector")
	proto.RegisterType((*Cluster_LeastRequestLbConfig)(nil), "envoy.api.v3alpha.Cluster.LeastRequestLbConfig")
	proto.RegisterType((*Cluster_RingHashLbConfig)(nil), "envoy.api.v3alpha.Cluster.RingHashLbConfig")
	proto.RegisterType((*Cluster_OriginalDstLbConfig)(nil), "envoy.api.v3alpha.Cluster.OriginalDstLbConfig")
	proto.RegisterType((*Cluster_CommonLbConfig)(nil), "envoy.api.v3alpha.Cluster.CommonLbConfig")
	proto.RegisterType((*Cluster_CommonLbConfig_ZoneAwareLbConfig)(nil), "envoy.api.v3alpha.Cluster.CommonLbConfig.ZoneAwareLbConfig")
	proto.RegisterType((*Cluster_CommonLbConfig_LocalityWeightedLbConfig)(nil), "envoy.api.v3alpha.Cluster.CommonLbConfig.LocalityWeightedLbConfig")
	proto.RegisterType((*Cluster_RefreshRate)(nil), "envoy.api.v3alpha.Cluster.RefreshRate")
	proto.RegisterType((*LoadBalancingPolicy)(nil), "envoy.api.v3alpha.LoadBalancingPolicy")
	proto.RegisterType((*LoadBalancingPolicy_Policy)(nil), "envoy.api.v3alpha.LoadBalancingPolicy.Policy")
	proto.RegisterType((*UpstreamBindConfig)(nil), "envoy.api.v3alpha.UpstreamBindConfig")
	proto.RegisterType((*UpstreamConnectionOptions)(nil), "envoy.api.v3alpha.UpstreamConnectionOptions")
}

func init() { proto.RegisterFile("envoy/api/v3alpha/cds.proto", fileDescriptor_1145bef7abd8c457) }

var fileDescriptor_1145bef7abd8c457 = []byte{
	// 3013 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xcd, 0x73, 0x1b, 0x47,
	0x76, 0xe7, 0x80, 0x10, 0x09, 0x36, 0x3e, 0x38, 0x6c, 0x52, 0xd2, 0x08, 0xd4, 0x07, 0x05, 0xc9,
	0x32, 0x45, 0xdb, 0xa4, 0x4d, 0xd9, 0x8e, 0x4b, 0x8e, 0x53, 0xc1, 0x17, 0x45, 0xc8, 0x20, 0x40,
	0x35, 0x00, 0xc9, 0x72, 0x5c, 0xd5, 0x6e, 0x0c, 0x1a, 0xc4, 0x84, 0x83, 0x19, 0x64, 0xba, 0x41,
	0x91, 0x3a, 0xb9, 0x9c, 0x54, 0x2a, 0x87, 0xdc, 0xf2, 0x07, 0xe4, 0x92, 0x4b, 0xfc, 0x07, 0xe4,
	0x9c, 0xcb, 0x5e, 0xb6, 0x6a, 0x4f, 0xbb, 0xd7, 0xbd, 0xed, 0x75, 0xff, 0x01, 0xed, 0x65, 0xab,
	0x3f, 0x06, 0x04, 0xf1, 0x45, 0x6a, 0xb7, 0xf6, 0x04, 0xf4, 0xeb, 0xf7, 0xfb, 0xbd, 0x9e, 0xe9,
	0xf7, 0x5e, 0xbf, 0xd7, 0x03, 0xd6, 0xa9, 0x77, 0xe2, 0x9f, 0xed, 0x90, 0x9e, 0xb3, 0x73, 0xf2,
	0x84, 0xb8, 0xbd, 0x0e, 0xd9, 0xb1, 0x5b, 0x6c, 0xbb, 0x17, 0xf8, 0xdc, 0x87, 0x2b, 0x72, 0x72,
	0x9b, 0xf4, 0x9c, 0x6d, 0x3d, 0x99, 0xde, 0x99, 0xa0, 0xef, 0xf6, 0x19, 0xa7, 0xc1, 0x8e, 0xed,
	0x04, 0x76, 0xdf, 0xe1, 0xb8, 0x19, 0x50, 0x72, 0x4c, 0x03, 0xc5, 0x91, 0x7e, 0x34, 0x1d, 0xd0,
	0x76, 0x5c, 0x3e, 0xd0, 0xfb, 0x6c, 0xba, 0x9e, 0xdf, 0xe7, 0xae, 0x43, 0x03, 0xdc, 0xa2, 0x9c,
	0xda, 0xdc, 0xf1, 0x3d, 0x0d, 0x79, 0x38, 0x01, 0xe2, 0x07, 0x74, 0x87, 0xb4, 0x5a, 0x01, 0x65,
	0xfa, 0x21, 0xd2, 0xf7, 0xa7, 0x68, 0x35, 0x09, 0xa3, 0x5a, 0x65, 0x6b, 0x8a, 0x8a, 0xed, 0x7b,
	0x6d, 0xe7, 0x08, 0x33, 0xbf, 0x1f, 0xd8, 0xa1, 0xee, 0xe3, 0x29, 0xba, 0x1d, 0x4a, 0x5c, 0xde,
	0xc1, 0x76, 0x87, 0xda, 0xc7, 0x5a, 0xf5, 0x83, 0x29, 0xaa, 0x72, 0xd6, 0xf6, 0xdd, 0xe9, 0x0b,
	0x6c, 0x39, 0xcc, 0xf6, 0x4f, 0x68, 0x70, 0xa6, 0x55, 0x26, 0xec, 0x12, 0x0d, 0x77, 0x29, 0xbd,
	0xa1, 0x26, 0xf9, 0x59, 0x8f, 0x0e, 0x66, 0x7b, 0x34, 0xb0, 0xa9, 0xc7, 0xb5, 0xc6, 0xed, 0x23,
	0xdf, 0x3f, 0x72, 0xa9, 0xc4, 0x13, 0xcf, 0xf3, 0x39, 0x11, 0x6f, 0x31, 0xc4, 0xdf, 0xd2, 0xb3,
	0x72, 0xd4, 0xec, 0xb7, 0x77, 0x88, 0x17, 0xda, 0xbd, 0x3b, 0x3a, 0xd5, 0xea, 0x07, 0x64, 0x68,
	0x07, 0x6e, 0x8f, 0xce, 0x33, 0x1e, 0xf4, 0x6d, 0x3e, 0x0d, 0xfd, 0x26, 0x20, 0xbd, 0x1e, 0x0d,
	0x42, 0xc3, 0x37, 0x4f, 0x88, 0xeb, 0xb4, 0x08, 0xa7, 0x3b, 0xe1, 0x1f, 0x35, 0x91, 0xf9, 0xd3,
	0xe7, 0x60, 0x31, 0xaf, 0x36, 0x1f, 0x3a, 0xc0, 0xe2, 0x01, 0xf1, 0x58, 0xcf, 0x0f, 0x38, 0x66,
	0xbe, 0x7d, 0x4c, 0x39, 0xee, 0x12, 0x6e, 0x77, 0x28, 0xb3, 0x3e, 0xda, 0x98, 0xdf, 0x8c, 0xef,
	0xee, 0x6c, 0x8f, 0xb9, 0xe9, 0xb6, 0x46, 0x6f, 0xd7, 0x43, 0x68, 0x4d, 0x22, 0x0f, 0x04, 0x10,
	0xdd, 0xe0, 0x13, 0xa4, 0x94, 0xc1, 0x75, 0x10, 0xf5, 0x48, 0x97, 0x5a, 0xc6, 0x86, 0xb1, 0xb9,
	0x94, 0x5b, 0x7c, 0x97, 0x8b, 0x06, 0x91, 0x0d, 0x03, 0x49, 0x21, 0xcc, 0x80, 0x24, 0x71, 0x39,
	0x66, 0x9c, 0x70, 0x2c, 0xb5, 0x6e, 0x0b, 0x2d, 0x14, 0x27, 0x2e, 0xaf, 0x71, 0xc2, 0x2b, 0x42,
	0x67, 0x1f, 0x44, 0xc5, 0x2e, 0x58, 0x91, 0x0d, 0x63, 0x33, 0xb5, 0xbb, 0x39, 0x63, 0x5d, 0x85,
	0x70, 0x83, 0xeb, 0x67, 0x3d, 0x9a, 0x8b, 0xbd, 0xcb, 0x5d, 0xfb, 0xd9, 0x88, 0x98, 0xc6, 0xfe,
	0x1c, 0x92, 0x0c, 0xf0, 0x05, 0x48, 0x68, 0xef, 0xc7, 0x92, 0xf1, 0xd1, 0x86, 0xb1, 0x19, 0xdf,
	0xfd, 0x78, 0x06, 0x63, 0xbe, 0xcf, 0xb8, 0xdf, 0xd5, 0x23, 0xc1, 0xba, 0x3f, 0x87, 0xe2, 0xf6,
	0xf9, 0x10, 0xbe, 0x06, 0x90, 0xb6, 0x18, 0x0e, 0x69, 0x95, 0x6f, 0x5b, 0xf3, 0x92, 0xf8, 0xa3,
	0x19, 0xc4, 0xc5, 0x16, 0xd3, 0x7f, 0xf3, 0x12, 0x82, 0x4c, 0x3a, 0x22, 0x81, 0x65, 0xb0, 0x6c,
	0xfb, 0x9e, 0x47, 0x6d, 0x8e, 0xb9, 0xd3, 0xa5, 0x7e, 0x9f, 0x5b, 0x51, 0xc9, 0x7b, 0x6b, 0x5b,
	0xb9, 0xc0, 0x76, 0xe8, 0x02, 0xdb, 0x05, 0xed, 0x40, 0xf2, 0x99, 0x7f, 0x31, 0x22, 0x5b, 0x73,
	0x28, 0xa5, 0xb1, 0x75, 0x05, 0x85, 0x6d, 0x70, 0xbf, 0xa7, 0x16, 0xe8, 0xa9, 0x70, 0xc7, 0xcd,
	0x7e, 0xbb, 0x4d, 0x03, 0xec, 0x3a, 0x5d, 0x91, 0x5e, 0xce, 0x38, 0x65, 0xd6, 0x35, 0xc9, 0x7f,
	0x7b, 0x8c, 0xbf, 0x51, 0xf2, 0xf8, 0x93, 0xdd, 0x97, 0xc4, 0xed, 0x53, 0x74, 0xa7, 0x27, 0x57,
	0xa8, 0x59, 0x72, 0x92, 0xa4, 0x2c, 0x38, 0x72, 0x82, 0x02, 0x3e, 0x07, 0x4b, 0x6e, 0x13, 0xf7,
	0x7c, 0xd7, 0xb1, 0xcf, 0xac, 0x05, 0xb9, 0x65, 0x0f, 0x66, 0xbc, 0x87, 0x72, 0xf3, 0x50, 0xaa,
	0x9e, 0xef, 0x16, 0x8a, 0xb9, 0x5a, 0x06, 0xbf, 0x00, 0xd7, 0x3a, 0x3e, 0xe3, 0xcc, 0x5a, 0x94,
	0x2e, 0x79, 0x6f, 0x02, 0x8f, 0x08, 0xfd, 0xed, 0xac, 0x4a, 0x4d, 0x48, 0x69, 0xc3, 0x17, 0x60,
	0xd9, 0xf5, 0x49, 0x0b, 0x13, 0xc6, 0x9c, 0x23, 0xaf, 0x4b, 0x3d, 0x6e, 0xdd, 0x97, 0x0f, 0x36,
	0xc3, 0x77, 0xca, 0x3e, 0x69, 0x65, 0x07, 0xfa, 0x28, 0xe5, 0x5e, 0x18, 0xc3, 0x7d, 0x90, 0x1c,
	0x4e, 0x45, 0xcc, 0x8a, 0xc9, 0x15, 0x3d, 0x98, 0xb6, 0xa2, 0x7d, 0xa9, 0x9c, 0x17, 0xba, 0x28,
	0xd1, 0x39, 0x1f, 0x30, 0xf8, 0x4f, 0x60, 0xbd, 0x4b, 0x4e, 0x71, 0x40, 0xff, 0xa5, 0x4f, 0x19,
	0x67, 0xf8, 0xe2, 0xa6, 0x58, 0x4b, 0x57, 0xd8, 0x01, 0xab, 0x4b, 0x4e, 0x91, 0xc6, 0x1f, 0x0e,
	0x6f, 0x06, 0x6c, 0x00, 0x73, 0xe4, 0xbc, 0x60, 0x16, 0x90, 0x8c, 0x5b, 0x93, 0x56, 0x1a, 0x3a,
	0xb9, 0x82, 0xe4, 0x34, 0x02, 0x2d, 0xdb, 0x17, 0x05, 0xd0, 0x05, 0xb7, 0x6d, 0xbf, 0xdb, 0xf5,
	0x3d, 0xdc, 0xe1, 0xbc, 0x87, 0xc3, 0x4c, 0x8b, 0xfd, 0x9e, 0xcc, 0x78, 0xd6, 0x9d, 0xa9, 0xee,
	0xae, 0x5e, 0x06, 0xe7, 0xbd, 0x43, 0x8d, 0xa9, 0x2a, 0x08, 0xba, 0xa5, 0x08, 0x27, 0x4c, 0xc1,
	0x1f, 0xc1, 0xf5, 0xc9, 0x66, 0x92, 0x53, 0xc3, 0x75, 0x60, 0xe6, 0xb3, 0x51, 0x3b, 0xab, 0x9d,
	0x09, 0x16, 0x9a, 0xe0, 0x86, 0x10, 0xef, 0x8e, 0x9b, 0x48, 0x5d, 0x6e, 0x62, 0x77, 0xd4, 0xc4,
	0x5a, 0x67, 0x82, 0x14, 0xfe, 0xbb, 0x01, 0x36, 0x44, 0x92, 0x69, 0x61, 0x7a, 0xca, 0xa9, 0xc7,
	0x44, 0xc4, 0x8d, 0x99, 0x7b, 0x28, 0xbd, 0xe8, 0x9b, 0x59, 0xa9, 0x56, 0x50, 0x14, 0x43, 0x86,
	0x11, 0x23, 0x45, 0x8f, 0x07, 0x67, 0xe8, 0x0e, 0x9f, 0xa5, 0x03, 0x5f, 0x00, 0xb3, 0xe5, 0x31,
	0x1c, 0xd0, 0x76, 0x40, 0x59, 0x07, 0x07, 0x84, 0x53, 0xcb, 0xbc, 0x2c, 0x8f, 0x24, 0xde, 0xe5,
	0x96, 0x7e, 0x31, 0x16, 0xb6, 0xa2, 0xe6, 0xff, 0xff, 0xdb, 0x37, 0x28, 0xd5, 0xf2, 0x18, 0x52,
	0x78, 0x44, 0x38, 0x85, 0x18, 0x58, 0x82, 0xb2, 0x4d, 0x1c, 0xb7, 0x1f, 0xd0, 0x8b, 0xd4, 0x1f,
	0x4b, 0xea, 0x47, 0x33, 0x1e, 0x69, 0x88, 0x09, 0x5d, 0x6f, 0x79, 0x6c, 0x4f, 0xd1, 0x0c, 0x1b,
	0x78, 0x04, 0x96, 0x03, 0xca, 0x7a, 0x22, 0xf5, 0x09, 0x43, 0x9c, 0xbb, 0xd6, 0x87, 0x1b, 0xc6,
	0x66, 0x0c, 0x25, 0xb5, 0xb8, 0xe0, 0xb1, 0x3a, 0x77, 0xe1, 0x8f, 0x60, 0x45, 0xcc, 0xbb, 0xbe,
	0x7f, 0xdc, 0xef, 0xe1, 0x36, 0xe9, 0x3a, 0xee, 0x99, 0xb5, 0x22, 0x93, 0xce, 0xd6, 0xac, 0x73,
	0xc2, 0x63, 0x65, 0x09, 0xd9, 0x93, 0x88, 0xa1, 0xdc, 0xb3, 0xdc, 0xba, 0x38, 0x05, 0x0b, 0x20,
	0xa9, 0xde, 0x1e, 0xf3, 0xdd, 0x13, 0x11, 0x4e, 0xf0, 0x6a, 0xa9, 0x28, 0x21, 0x5f, 0x99, 0x06,
	0xc1, 0xef, 0xc0, 0xca, 0x58, 0xb9, 0x65, 0xad, 0x4e, 0x8f, 0x1a, 0xbd, 0xce, 0xaa, 0xc2, 0x14,
	0x42, 0x08, 0x32, 0xfd, 0x11, 0x09, 0xac, 0x00, 0xd3, 0x76, 0x29, 0xf1, 0xfa, 0x3d, 0xec, 0x78,
	0x9c, 0x06, 0x27, 0xc4, 0xb5, 0xd6, 0xae, 0x7e, 0x4a, 0x2c, 0x6b, 0x70, 0x49, 0x63, 0x61, 0x1d,
	0xac, 0xf5, 0x7b, 0x8c, 0x07, 0x94, 0x74, 0x71, 0xd3, 0xf1, 0x5a, 0xe1, 0x89, 0x76, 0x5d, 0x72,
	0x66, 0xa6, 0x3d, 0x76, 0xce, 0xf1, 0x5a, 0xfa, 0x20, 0x83, 0x21, 0xfe, 0x5c, 0x06, 0x6b, 0xc0,
	0x74, 0x9b, 0x98, 0xf5, 0x9b, 0x8c, 0xf2, 0x90, 0xf1, 0x86, 0x64, 0x7c, 0x3c, 0xf3, 0x6c, 0xa8,
	0x49, 0x84, 0x26, 0x4e, 0xb9, 0x17, 0xc6, 0xf0, 0x07, 0xb0, 0x1a, 0x38, 0xde, 0x11, 0xee, 0x10,
	0xd6, 0xc1, 0x6e, 0x33, 0xe4, 0xbd, 0x79, 0xe9, 0xd9, 0x8b, 0x1c, 0xef, 0x68, 0x9f, 0xb0, 0x4e,
	0xb9, 0xa9, 0x98, 0xf6, 0x0d, 0x64, 0x06, 0x23, 0x32, 0x48, 0xc1, 0x0d, 0x3f, 0x70, 0x8e, 0x1c,
	0x8f, 0xb8, 0xb8, 0xc5, 0xf8, 0x90, 0x81, 0x8c, 0x34, 0xb0, 0x3d, 0xc3, 0x40, 0x55, 0x03, 0x0b,
	0x8c, 0x0f, 0xd9, 0x58, 0xf5, 0xc7, 0xc5, 0xb0, 0x03, 0x6e, 0xba, 0x94, 0x30, 0x1e, 0x1e, 0x08,
	0x43, 0x76, 0x3e, 0x90, 0x76, 0x66, 0xd5, 0x61, 0x65, 0x81, 0xd4, 0x27, 0xc1, 0x90, 0xa1, 0x35,
	0x77, 0x82, 0x5c, 0xec, 0x81, 0x4e, 0xe2, 0xe7, 0x26, 0xd6, 0x2f, 0xdd, 0x83, 0xbc, 0x84, 0x84,
	0x24, 0xa2, 0xaa, 0x18, 0x1e, 0x43, 0x04, 0xcc, 0xd1, 0x3a, 0xd2, 0xb2, 0x24, 0xe9, 0x87, 0xd3,
	0x5c, 0x65, 0xa4, 0x78, 0x44, 0xcb, 0x23, 0x75, 0x23, 0xfc, 0x7b, 0x10, 0xeb, 0x52, 0x4e, 0x5a,
	0x84, 0x13, 0xeb, 0x96, 0xe4, 0xda, 0x98, 0xc6, 0x75, 0xa0, 0xf5, 0xd0, 0x00, 0x01, 0x9b, 0x00,
	0x0e, 0xd2, 0x2c, 0xa3, 0xae, 0x8e, 0xb5, 0xb4, 0xcc, 0x09, 0x4f, 0x66, 0x3d, 0xa8, 0xfa, 0x0d,
	0xb3, 0x67, 0x2d, 0x84, 0xa2, 0x95, 0xde, 0xa8, 0x08, 0xba, 0x60, 0x7d, 0x10, 0x24, 0x43, 0x05,
	0x55, 0x98, 0xd5, 0xef, 0x4e, 0x3d, 0x44, 0x1a, 0x1a, 0x75, 0x7e, 0x64, 0x0f, 0xce, 0xc3, 0xfe,
	0xb4, 0x29, 0xd8, 0x00, 0x9b, 0xb6, 0xeb, 0x33, 0x3a, 0x64, 0x8a, 0x61, 0x71, 0x16, 0xfb, 0x8c,
	0x63, 0x5d, 0x95, 0xe8, 0x54, 0x6c, 0xdd, 0x93, 0x59, 0xf2, 0x81, 0xd4, 0x3f, 0x67, 0x62, 0x55,
	0x6f, 0xdf, 0x67, 0x5c, 0x15, 0x25, 0x3a, 0xdd, 0xc2, 0x7d, 0x70, 0xbf, 0x15, 0x10, 0xc7, 0x9b,
	0x48, 0x1b, 0xd0, 0xae, 0x2f, 0x52, 0xc9, 0x86, 0xe4, 0xbb, 0x23, 0x15, 0xc7, 0xf8, 0x90, 0x52,
	0x82, 0x5f, 0x83, 0x45, 0xd5, 0x74, 0x32, 0x6b, 0x53, 0x66, 0xc7, 0xfb, 0x33, 0x72, 0xda, 0x9e,
	0xd4, 0x44, 0x21, 0x02, 0x7e, 0x0f, 0xae, 0xcb, 0x62, 0xad, 0x49, 0x5c, 0xe2, 0xd9, 0x22, 0x9e,
	0x75, 0xed, 0xf8, 0x78, 0xea, 0x41, 0x22, 0x6a, 0xb5, 0x5c, 0xa8, 0xae, 0x4a, 0x45, 0xb4, 0xea,
	0x8e, 0x0b, 0x61, 0x1e, 0x00, 0x37, 0x60, 0x98, 0xd1, 0xe0, 0x84, 0x06, 0xd6, 0x96, 0x24, 0x7c,
	0x38, 0xcd, 0x97, 0x94, 0x47, 0xd7, 0x64, 0x57, 0x8a, 0x96, 0xdc, 0x80, 0xd5, 0x24, 0x2c, 0xfd,
	0x7f, 0x06, 0x58, 0x9b, 0xd4, 0xf0, 0x4c, 0x6c, 0x6c, 0xcc, 0xb0, 0xb1, 0xf9, 0x04, 0x5c, 0x93,
	0xfd, 0x94, 0xec, 0x5a, 0xe2, 0xbb, 0x37, 0xc7, 0x92, 0x71, 0x4d, 0xf6, 0x74, 0x48, 0x69, 0x4d,
	0x8c, 0xa3, 0xf9, 0xbf, 0x2e, 0x8e, 0xd2, 0x0e, 0x58, 0x19, 0x6b, 0x5f, 0x66, 0x77, 0x63, 0x7f,
	0x07, 0x12, 0xaa, 0x64, 0xd1, 0xe9, 0x41, 0xad, 0x7d, 0x6d, 0x6c, 0xed, 0x59, 0xef, 0x0c, 0xc5,
	0xa5, 0xa6, 0x7a, 0x69, 0xe9, 0xb7, 0xc0, 0x1c, 0x6d, 0x68, 0xc4, 0xcb, 0x97, 0x9d, 0x91, 0xa2,
	0x32, 0xde, 0xe7, 0xe5, 0x8b, 0x56, 0x48, 0x91, 0xdc, 0x07, 0x09, 0xb1, 0x7b, 0x8e, 0x4d, 0x55,
	0x7b, 0x18, 0x51, 0xed, 0xa1, 0x96, 0x89, 0xf6, 0x30, 0xfd, 0x9b, 0x05, 0x90, 0xba, 0x78, 0x52,
	0x40, 0x06, 0x96, 0xdb, 0xc4, 0x75, 0x9b, 0xc4, 0x3e, 0x0e, 0xbd, 0xc9, 0x90, 0x09, 0xe0, 0x1f,
	0xaf, 0x7c, 0xda, 0x0c, 0x86, 0x7b, 0x9a, 0x68, 0xac, 0x4d, 0x49, 0xb5, 0x2f, 0xcc, 0xc0, 0x7f,
	0x00, 0xa9, 0x16, 0x6d, 0x93, 0xbe, 0x68, 0x67, 0x25, 0xf2, 0xb2, 0xad, 0x4f, 0x6a, 0x75, 0x65,
	0x07, 0x52, 0x60, 0xea, 0x03, 0x52, 0xa5, 0x2d, 0x3f, 0x60, 0xd6, 0xbc, 0x0c, 0xa7, 0xa7, 0xef,
	0xbf, 0xea, 0x9a, 0xa6, 0x40, 0xcb, 0xec, 0xc2, 0x98, 0xc1, 0x5d, 0x11, 0x6f, 0x36, 0x71, 0x1d,
	0x7e, 0x86, 0xdf, 0x50, 0xe7, 0xa8, 0xc3, 0x31, 0x79, 0x43, 0x02, 0x2a, 0x7b, 0xcb, 0x98, 0x88,
	0x23, 0x35, 0xf9, 0x4a, 0xce, 0x65, 0xc5, 0x94, 0xc0, 0x30, 0x9b, 0xb8, 0x14, 0x8f, 0x20, 0x65,
	0xbf, 0x18, 0x43, 0xab, 0x72, 0xb2, 0x7c, 0x01, 0x08, 0x1f, 0x82, 0x54, 0x8f, 0x78, 0x8e, 0x8d,
	0xbb, 0x7e, 0x8b, 0x62, 0xe2, 0xa9, 0x66, 0x30, 0x86, 0x12, 0x52, 0x7a, 0xe0, 0xb7, 0x68, 0xd6,
	0x3b, 0x83, 0x77, 0x41, 0xdc, 0x75, 0x18, 0xc7, 0x84, 0x49, 0x95, 0x45, 0xa9, 0xb2, 0x24, 0x44,
	0x59, 0x96, 0xf5, 0xce, 0xd2, 0xff, 0x1d, 0x01, 0xe6, 0xe8, 0x33, 0x41, 0x08, 0xa2, 0xc7, 0xf4,
	0x8c, 0x59, 0xc6, 0xc6, 0xfc, 0xe6, 0x12, 0x92, 0xff, 0xe1, 0x7f, 0x1a, 0xe3, 0x7b, 0xae, 0x2e,
	0x0c, 0x5e, 0xff, 0xe5, 0x6f, 0x6f, 0x4c, 0x70, 0x55, 0x67, 0xc8, 0x74, 0xc0, 0xdd, 0xd9, 0x58,
	0xb8, 0x0c, 0xe2, 0x95, 0x6a, 0x1d, 0x17, 0x8a, 0x7b, 0xa5, 0x4a, 0xb1, 0x60, 0xce, 0x29, 0x01,
	0xde, 0xcb, 0x96, 0xcb, 0xb9, 0x6c, 0xfe, 0x5b, 0xd3, 0x80, 0x26, 0x48, 0x64, 0x2b, 0xaf, 0x71,
	0xb1, 0x52, 0x38, 0xac, 0x96, 0x2a, 0x75, 0x33, 0x02, 0x21, 0x48, 0x15, 0x8a, 0x7b, 0xd9, 0x46,
	0xb9, 0x8e, 0x6b, 0x8d, 0x5c, 0xad, 0x58, 0x37, 0xe7, 0x33, 0x55, 0x70, 0x63, 0xb2, 0xab, 0x8e,
	0x12, 0xce, 0x8d, 0x11, 0x1a, 0x13, 0x08, 0x23, 0xe9, 0x1f, 0xc1, 0xda, 0xa4, 0xba, 0x02, 0xee,
	0x83, 0x84, 0xdd, 0xf1, 0x45, 0x24, 0xda, 0x7e, 0xdf, 0xe3, 0x3a, 0xa2, 0x67, 0x76, 0xaa, 0x32,
	0xbf, 0x6c, 0x45, 0x36, 0x23, 0x28, 0xae, 0xa0, 0x79, 0x81, 0x4c, 0xff, 0x3e, 0x02, 0xcc, 0xd1,
	0x1a, 0x0c, 0xd6, 0xc1, 0x4a, 0xd7, 0xf1, 0x9c, 0x6e, 0xbf, 0x8b, 0x65, 0x55, 0xc7, 0x9c, 0xb7,
	0x74, 0xa6, 0x8d, 0x2f, 0x3f, 0x57, 0x36, 0xc0, 0xbb, 0xdc, 0xe2, 0xee, 0x35, 0xeb, 0xa7, 0x9f,
	0x7e, 0x8a, 0xa2, 0x65, 0x4d, 0x21, 0xd8, 0x6b, 0xce, 0x5b, 0x0a, 0x8f, 0x40, 0x52, 0x96, 0x87,
	0xed, 0xbe, 0xa7, 0x0a, 0x81, 0x79, 0xe9, 0x13, 0x5f, 0xbd, 0x47, 0x75, 0xb8, 0x2d, 0x06, 0x7b,
	0x1a, 0x3f, 0xb4, 0xe5, 0x89, 0xce, 0x90, 0x5c, 0x2e, 0x9f, 0x9c, 0x8e, 0x2c, 0x3f, 0xfa, 0xde,
	0xcb, 0x57, 0x14, 0xe1, 0xf2, 0x33, 0xdb, 0x20, 0x31, 0x6c, 0x1d, 0xc6, 0xc1, 0xe2, 0x77, 0xdf,
	0xe1, 0xfd, 0x6c, 0x6d, 0xdf, 0x9c, 0x83, 0x2b, 0x20, 0x79, 0xd0, 0x40, 0x07, 0x0d, 0x24, 0x05,
	0x78, 0xd7, 0x34, 0x9e, 0x47, 0x63, 0x11, 0x73, 0x3e, 0xfd, 0x0d, 0x58, 0x9d, 0x50, 0x81, 0x8a,
	0xa6, 0xaa, 0xcf, 0xa8, 0x6a, 0xe1, 0x3b, 0x94, 0xb4, 0x68, 0x20, 0xdf, 0x6f, 0x0c, 0x25, 0xfb,
	0x8c, 0x8a, 0xce, 0x76, 0x5f, 0x0a, 0xd3, 0xbf, 0x5e, 0x00, 0xa9, 0x8b, 0x65, 0x1f, 0xac, 0x81,
	0x9b, 0xaa, 0xd0, 0x38, 0xc3, 0x2a, 0xa8, 0x79, 0x47, 0xf4, 0x6a, 0xbe, 0xdb, 0xd2, 0x5b, 0xb4,
	0xae, 0x5f, 0xa8, 0x38, 0x14, 0x06, 0x6f, 0xf4, 0x50, 0x5d, 0x97, 0xa2, 0xeb, 0x1a, 0x7b, 0x28,
	0xa0, 0xf5, 0x10, 0x09, 0x3d, 0xb0, 0xf6, 0xd6, 0xf7, 0xa8, 0x4a, 0x3f, 0x43, 0x45, 0xa9, 0x4a,
	0x9b, 0x5f, 0x5f, 0xb9, 0x28, 0xdd, 0xfe, 0xde, 0xf7, 0xa8, 0x4c, 0x54, 0x83, 0x1a, 0x78, 0x0e,
	0xad, 0xbc, 0x1d, 0x15, 0xc2, 0x7f, 0x35, 0xc0, 0xfa, 0x48, 0x02, 0xa3, 0xad, 0x21, 0xbb, 0xea,
	0xbc, 0xcd, 0x5d, 0xdd, 0xee, 0xc5, 0x8c, 0x47, 0x5b, 0x43, 0xe6, 0x2d, 0x77, 0xca, 0x1c, 0x2c,
	0x81, 0xd5, 0x7e, 0xaf, 0x45, 0x38, 0xc5, 0x5d, 0x1a, 0x1c, 0x51, 0xfc, 0xc6, 0xf1, 0x5a, 0xfe,
	0x9b, 0x4b, 0x6f, 0xf6, 0xd0, 0x8a, 0x42, 0x1d, 0x08, 0xd0, 0x2b, 0x89, 0x81, 0x79, 0x70, 0xcf,
	0x39, 0xf2, 0xfc, 0x80, 0x62, 0x8f, 0xbe, 0x91, 0x75, 0x1b, 0xc3, 0x7d, 0x8f, 0x3b, 0x2e, 0x6e,
	0x3b, 0x81, 0xa8, 0x0d, 0x6d, 0x9d, 0xa0, 0xd3, 0x4a, 0xad, 0x42, 0xdf, 0x88, 0xb2, 0x8d, 0x35,
	0x84, 0xce, 0x9e, 0x50, 0xd9, 0xb7, 0xe1, 0x01, 0x78, 0x38, 0xbd, 0xba, 0x94, 0xed, 0x5a, 0x87,
	0x78, 0x47, 0x54, 0x67, 0xef, 0x7b, 0x93, 0x2b, 0xcb, 0x1a, 0xe5, 0x79, 0xa9, 0x96, 0xfe, 0x9d,
	0x01, 0x56, 0xc6, 0xf6, 0x03, 0x16, 0xc0, 0x72, 0xe0, 0xf7, 0xb9, 0x08, 0x0c, 0xea, 0x91, 0xa6,
	0x4b, 0xaf, 0xe4, 0x37, 0x29, 0x8d, 0x29, 0x2a, 0x08, 0xdc, 0x03, 0x66, 0x57, 0xd4, 0xab, 0xfa,
	0xae, 0x55, 0x86, 0x58, 0xe4, 0xf2, 0x10, 0x43, 0xa9, 0xae, 0xe3, 0xe9, 0x2d, 0x94, 0x49, 0xe1,
	0x33, 0x70, 0x5d, 0xd4, 0xcb, 0x98, 0x07, 0xa4, 0xdd, 0x76, 0x6c, 0xf1, 0xb4, 0xd2, 0xab, 0xa5,
	0x07, 0xc4, 0x10, 0x14, 0x93, 0x75, 0x35, 0x57, 0xf5, 0xa4, 0xd3, 0xa6, 0xd3, 0xc0, 0x9a, 0xb6,
	0xdb, 0xb9, 0x75, 0x70, 0x6b, 0xe0, 0x56, 0xe1, 0xb7, 0x8d, 0x1e, 0xb5, 0x9d, 0xb6, 0x43, 0x83,
	0xf4, 0xff, 0x1a, 0x20, 0x3e, 0x7c, 0xb3, 0x51, 0x01, 0xc9, 0x26, 0x61, 0xf4, 0xbc, 0x59, 0x37,
	0x2e, 0x6b, 0xd6, 0x53, 0xef, 0x72, 0xf1, 0x5f, 0x8c, 0x58, 0xcc, 0xd0, 0x97, 0x31, 0x09, 0x81,
	0x1f, 0xf4, 0xeb, 0xcf, 0x41, 0xa2, 0x4b, 0x4e, 0xcf, 0xe9, 0x22, 0xef, 0x77, 0xb3, 0x13, 0xef,
	0x92, 0xd3, 0x90, 0x2b, 0xdd, 0x06, 0x99, 0xcb, 0xaf, 0x9b, 0xa0, 0x09, 0xe6, 0x8f, 0xa9, 0x2a,
	0xa8, 0x96, 0x90, 0xf8, 0x0b, 0xb7, 0xc0, 0xb5, 0x13, 0xf1, 0xa2, 0x67, 0xd6, 0x8b, 0x4a, 0xe5,
	0x69, 0xe4, 0x2b, 0x23, 0xf3, 0x0a, 0x24, 0x2f, 0xdc, 0xd4, 0x43, 0x00, 0x16, 0x6a, 0xf5, 0x6c,
	0xbd, 0x94, 0x37, 0xe7, 0x60, 0x0a, 0x80, 0x5a, 0x1d, 0x95, 0xf2, 0x75, 0x5c, 0xa8, 0xd4, 0x4c,
	0x43, 0x9c, 0x62, 0xe5, 0xea, 0xb3, 0x52, 0x3e, 0x5b, 0x96, 0x82, 0x08, 0x5c, 0x04, 0xf3, 0xc5,
	0x42, 0xcd, 0x9c, 0x17, 0xc7, 0x59, 0x15, 0x95, 0x9e, 0x95, 0x2a, 0x62, 0xaa, 0x56, 0x37, 0xa3,
	0x99, 0xff, 0x31, 0x40, 0x2c, 0xbc, 0x50, 0x16, 0x40, 0x54, 0x6d, 0x54, 0x0a, 0x18, 0x55, 0x73,
	0xa5, 0x8a, 0xca, 0x97, 0xe5, 0x62, 0xb6, 0x56, 0xc7, 0xa8, 0xf8, 0xa2, 0x51, 0xac, 0x89, 0xf3,
	0x2f, 0x09, 0x96, 0x50, 0xa9, 0xf2, 0x4c, 0x65, 0xd4, 0x88, 0x58, 0x07, 0xca, 0x56, 0x0a, 0xd5,
	0x03, 0x73, 0x5e, 0xfc, 0x3f, 0xc8, 0x3e, 0x2b, 0x17, 0x5f, 0x9a, 0xd7, 0xe0, 0x1a, 0x30, 0xf3,
	0xe5, 0x46, 0xad, 0x5e, 0x44, 0xf8, 0x10, 0x55, 0x5f, 0x96, 0x0a, 0xc5, 0x82, 0xb9, 0x00, 0x37,
	0xc0, 0xed, 0x72, 0x35, 0x5b, 0xc0, 0xb9, 0x6c, 0x39, 0x5b, 0xc9, 0x0b, 0x9a, 0xc3, 0x6a, 0xb9,
	0x94, 0x7f, 0x8d, 0xf3, 0xd5, 0xca, 0x5e, 0xe9, 0x99, 0xb9, 0x98, 0x89, 0xc6, 0xa2, 0x66, 0x74,
	0x6b, 0x79, 0x78, 0x95, 0xb8, 0x9c, 0xcb, 0x7c, 0x01, 0x96, 0x47, 0x6e, 0xa0, 0x60, 0x0c, 0x44,
	0xb3, 0x8d, 0x7a, 0xd5, 0x9c, 0x13, 0x29, 0xfe, 0xe5, 0xe7, 0xb8, 0x5a, 0x29, 0xbf, 0x36, 0x0d,
	0x39, 0xf8, 0x52, 0x0d, 0x22, 0x99, 0x3a, 0xb0, 0xa6, 0x35, 0xa9, 0x70, 0x1d, 0xdc, 0x6c, 0xd4,
	0x8a, 0xda, 0x72, 0x03, 0x15, 0x0b, 0x62, 0xa1, 0xf5, 0x6a, 0xbe, 0x5a, 0x36, 0xe7, 0xc2, 0xc9,
	0x42, 0xf5, 0x55, 0xa5, 0x56, 0x47, 0xc5, 0xec, 0xc1, 0xf9, 0xa4, 0x91, 0xb3, 0xc0, 0x8d, 0x30,
	0xa0, 0x06, 0xdf, 0xc7, 0xe4, 0xd7, 0x91, 0x5c, 0x5c, 0xde, 0xe4, 0x2b, 0x8f, 0x7e, 0x1e, 0x8d,
	0x25, 0xcc, 0xe4, 0xf3, 0x68, 0x6c, 0xd9, 0x34, 0x9f, 0x47, 0x63, 0x71, 0x33, 0xf1, 0x3c, 0x1a,
	0x7b, 0x60, 0x3e, 0x44, 0x71, 0xee, 0xca, 0x1a, 0x9f, 0xd3, 0x53, 0x8e, 0xd2, 0xd3, 0xaf, 0x3a,
	0x33, 0xbf, 0x32, 0xc0, 0xea, 0x84, 0xc6, 0x0d, 0x96, 0x40, 0x4c, 0x96, 0x6b, 0x0e, 0x55, 0x05,
	0x5d, 0x7c, 0xf7, 0x93, 0xab, 0xb5, 0x7c, 0xdb, 0xba, 0xf3, 0x1b, 0xc0, 0xd3, 0x36, 0x58, 0xd0,
	0xa4, 0x70, 0xb8, 0xcb, 0x99, 0xd2, 0xdc, 0xcc, 0x5f, 0xb1, 0xb9, 0x51, 0x87, 0x2a, 0x5a, 0x50,
	0xb0, 0xcc, 0x0f, 0x00, 0x36, 0xc6, 0x2f, 0xb8, 0xf6, 0x40, 0x4a, 0x7d, 0xcf, 0xc4, 0xfa, 0x33,
	0xa9, 0x8e, 0xeb, 0x4b, 0xef, 0x09, 0x93, 0x0a, 0xa6, 0x87, 0x99, 0x36, 0xb8, 0x35, 0xf5, 0x8e,
	0x00, 0x96, 0x40, 0x92, 0xdb, 0x3d, 0x7c, 0x4c, 0x69, 0x8f, 0xb8, 0xce, 0x09, 0xbd, 0xac, 0xa9,
	0xaa, 0xdb, 0xbd, 0x6f, 0x43, 0x5d, 0x94, 0xe0, 0x43, 0xa3, 0xdd, 0x3f, 0x46, 0xc0, 0x4d, 0xed,
	0x4c, 0x83, 0x50, 0xac, 0xa9, 0xa6, 0x0a, 0x12, 0x90, 0xaa, 0xa9, 0x15, 0x28, 0x05, 0x06, 0x27,
	0x7d, 0xe6, 0x18, 0xc0, 0x74, 0x9d, 0x98, 0x7e, 0x38, 0x5b, 0x89, 0xf5, 0x7c, 0x8f, 0xd1, 0xcc,
	0xdc, 0xa6, 0xf1, 0xa9, 0x01, 0xff, 0x19, 0x24, 0x0b, 0xd4, 0xe5, 0x64, 0x60, 0x61, 0xd2, 0x97,
	0x19, 0xa9, 0x31, 0x66, 0xe6, 0xf1, 0x15, 0x34, 0x2f, 0xd8, 0xfa, 0xd9, 0x00, 0xc9, 0x3d, 0xca,
	0xed, 0xce, 0xdf, 0xe2, 0x71, 0x1e, 0xfd, 0xfc, 0xdb, 0x3f, 0xfc, 0x57, 0x64, 0x23, 0xb3, 0x3e,
	0xfe, 0x91, 0xf9, 0xa9, 0x0e, 0x2b, 0xf6, 0xd4, 0xd8, 0xca, 0x7d, 0x0a, 0xee, 0x39, 0xbe, 0x62,
	0xec, 0x05, 0xfe, 0xe9, 0xd9, 0x38, 0x79, 0x2e, 0x96, 0x6f, 0x31, 0x19, 0xd8, 0x87, 0xc6, 0x7f,
	0x18, 0x46, 0x73, 0x41, 0x3a, 0xe4, 0x93, 0x3f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x47, 0x19, 0xa6,
	0x7a, 0x4b, 0x20, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ClusterDiscoveryServiceClient is the client API for ClusterDiscoveryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ClusterDiscoveryServiceClient interface {
	StreamClusters(ctx context.Context, opts ...grpc.CallOption) (ClusterDiscoveryService_StreamClustersClient, error)
	DeltaClusters(ctx context.Context, opts ...grpc.CallOption) (ClusterDiscoveryService_DeltaClustersClient, error)
	FetchClusters(ctx context.Context, in *DiscoveryRequest, opts ...grpc.CallOption) (*DiscoveryResponse, error)
}

type clusterDiscoveryServiceClient struct {
	cc *grpc.ClientConn
}

func NewClusterDiscoveryServiceClient(cc *grpc.ClientConn) ClusterDiscoveryServiceClient {
	return &clusterDiscoveryServiceClient{cc}
}

func (c *clusterDiscoveryServiceClient) StreamClusters(ctx context.Context, opts ...grpc.CallOption) (ClusterDiscoveryService_StreamClustersClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ClusterDiscoveryService_serviceDesc.Streams[0], "/envoy.api.v3alpha.ClusterDiscoveryService/StreamClusters", opts...)
	if err != nil {
		return nil, err
	}
	x := &clusterDiscoveryServiceStreamClustersClient{stream}
	return x, nil
}

type ClusterDiscoveryService_StreamClustersClient interface {
	Send(*DiscoveryRequest) error
	Recv() (*DiscoveryResponse, error)
	grpc.ClientStream
}

type clusterDiscoveryServiceStreamClustersClient struct {
	grpc.ClientStream
}

func (x *clusterDiscoveryServiceStreamClustersClient) Send(m *DiscoveryRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *clusterDiscoveryServiceStreamClustersClient) Recv() (*DiscoveryResponse, error) {
	m := new(DiscoveryResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *clusterDiscoveryServiceClient) DeltaClusters(ctx context.Context, opts ...grpc.CallOption) (ClusterDiscoveryService_DeltaClustersClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ClusterDiscoveryService_serviceDesc.Streams[1], "/envoy.api.v3alpha.ClusterDiscoveryService/DeltaClusters", opts...)
	if err != nil {
		return nil, err
	}
	x := &clusterDiscoveryServiceDeltaClustersClient{stream}
	return x, nil
}

type ClusterDiscoveryService_DeltaClustersClient interface {
	Send(*DeltaDiscoveryRequest) error
	Recv() (*DeltaDiscoveryResponse, error)
	grpc.ClientStream
}

type clusterDiscoveryServiceDeltaClustersClient struct {
	grpc.ClientStream
}

func (x *clusterDiscoveryServiceDeltaClustersClient) Send(m *DeltaDiscoveryRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *clusterDiscoveryServiceDeltaClustersClient) Recv() (*DeltaDiscoveryResponse, error) {
	m := new(DeltaDiscoveryResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *clusterDiscoveryServiceClient) FetchClusters(ctx context.Context, in *DiscoveryRequest, opts ...grpc.CallOption) (*DiscoveryResponse, error) {
	out := new(DiscoveryResponse)
	err := c.cc.Invoke(ctx, "/envoy.api.v3alpha.ClusterDiscoveryService/FetchClusters", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ClusterDiscoveryServiceServer is the server API for ClusterDiscoveryService service.
type ClusterDiscoveryServiceServer interface {
	StreamClusters(ClusterDiscoveryService_StreamClustersServer) error
	DeltaClusters(ClusterDiscoveryService_DeltaClustersServer) error
	FetchClusters(context.Context, *DiscoveryRequest) (*DiscoveryResponse, error)
}

// UnimplementedClusterDiscoveryServiceServer can be embedded to have forward compatible implementations.
type UnimplementedClusterDiscoveryServiceServer struct {
}

func (*UnimplementedClusterDiscoveryServiceServer) StreamClusters(srv ClusterDiscoveryService_StreamClustersServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamClusters not implemented")
}
func (*UnimplementedClusterDiscoveryServiceServer) DeltaClusters(srv ClusterDiscoveryService_DeltaClustersServer) error {
	return status.Errorf(codes.Unimplemented, "method DeltaClusters not implemented")
}
func (*UnimplementedClusterDiscoveryServiceServer) FetchClusters(ctx context.Context, req *DiscoveryRequest) (*DiscoveryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FetchClusters not implemented")
}

func RegisterClusterDiscoveryServiceServer(s *grpc.Server, srv ClusterDiscoveryServiceServer) {
	s.RegisterService(&_ClusterDiscoveryService_serviceDesc, srv)
}

func _ClusterDiscoveryService_StreamClusters_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ClusterDiscoveryServiceServer).StreamClusters(&clusterDiscoveryServiceStreamClustersServer{stream})
}

type ClusterDiscoveryService_StreamClustersServer interface {
	Send(*DiscoveryResponse) error
	Recv() (*DiscoveryRequest, error)
	grpc.ServerStream
}

type clusterDiscoveryServiceStreamClustersServer struct {
	grpc.ServerStream
}

func (x *clusterDiscoveryServiceStreamClustersServer) Send(m *DiscoveryResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *clusterDiscoveryServiceStreamClustersServer) Recv() (*DiscoveryRequest, error) {
	m := new(DiscoveryRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ClusterDiscoveryService_DeltaClusters_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ClusterDiscoveryServiceServer).DeltaClusters(&clusterDiscoveryServiceDeltaClustersServer{stream})
}

type ClusterDiscoveryService_DeltaClustersServer interface {
	Send(*DeltaDiscoveryResponse) error
	Recv() (*DeltaDiscoveryRequest, error)
	grpc.ServerStream
}

type clusterDiscoveryServiceDeltaClustersServer struct {
	grpc.ServerStream
}

func (x *clusterDiscoveryServiceDeltaClustersServer) Send(m *DeltaDiscoveryResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *clusterDiscoveryServiceDeltaClustersServer) Recv() (*DeltaDiscoveryRequest, error) {
	m := new(DeltaDiscoveryRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ClusterDiscoveryService_FetchClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiscoveryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ClusterDiscoveryServiceServer).FetchClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/envoy.api.v3alpha.ClusterDiscoveryService/FetchClusters",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterDiscoveryServiceServer).FetchClusters(ctx, req.(*DiscoveryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ClusterDiscoveryService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "envoy.api.v3alpha.ClusterDiscoveryService",
	HandlerType: (*ClusterDiscoveryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FetchClusters",
			Handler:    _ClusterDiscoveryService_FetchClusters_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamClusters",
			Handler:       _ClusterDiscoveryService_StreamClusters_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "DeltaClusters",
			Handler:       _ClusterDiscoveryService_DeltaClusters_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "envoy/api/v3alpha/cds.proto",
}
