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

package envoy_api_v2

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import any "github.com/golang/protobuf/ptypes/any"
import duration "github.com/golang/protobuf/ptypes/duration"
import _struct "github.com/golang/protobuf/ptypes/struct"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import cert "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/auth/cert"
import circuit_breaker "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/cluster/circuit_breaker"
import outlier_detection "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/cluster/outlier_detection"
import address "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/core/address"
import base "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/core/base"
import config_source "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/core/config_source"
import health_check "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/core/health_check"
import protocol "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/core/protocol"
import discovery "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/discovery"
import eds "google.golang.org/grpc/balancer/xds/internal/proto/envoy/api/v2/eds"
import percent "google.golang.org/grpc/balancer/xds/internal/proto/envoy/type/percent"
import _ "google.golang.org/grpc/balancer/xds/internal/proto/validate"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// 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.ProtoPackageIsVersion2 // 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_cds_3e3c13a974b77399, []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_ORIGINAL_DST_LB  Cluster_LbPolicy = 4
	Cluster_MAGLEV           Cluster_LbPolicy = 5
	Cluster_CLUSTER_PROVIDED Cluster_LbPolicy = 6
)

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

func (x Cluster_LbPolicy) String() string {
	return proto.EnumName(Cluster_LbPolicy_name, int32(x))
}
func (Cluster_LbPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cds_3e3c13a974b77399, []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_cds_3e3c13a974b77399, []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_cds_3e3c13a974b77399, []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_cds_3e3c13a974b77399, []int{0, 4, 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_cds_3e3c13a974b77399, []int{0, 4, 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_cds_3e3c13a974b77399, []int{0, 6, 0}
}

type Cluster struct {
	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.v2.Cluster_LbPolicy" json:"lb_policy,omitempty"`
	Hosts                         []*address.Address                  `protobuf:"bytes,7,rep,name=hosts,proto3" json:"hosts,omitempty"` // Deprecated: Do not use.
	LoadAssignment                *eds.ClusterLoadAssignment          `protobuf:"bytes,33,opt,name=load_assignment,json=loadAssignment,proto3" json:"load_assignment,omitempty"`
	HealthChecks                  []*health_check.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               *circuit_breaker.CircuitBreakers    `protobuf:"bytes,10,opt,name=circuit_breakers,json=circuitBreakers,proto3" json:"circuit_breakers,omitempty"`
	TlsContext                    *cert.UpstreamTlsContext            `protobuf:"bytes,11,opt,name=tls_context,json=tlsContext,proto3" json:"tls_context,omitempty"`
	CommonHttpProtocolOptions     *protocol.HttpProtocolOptions       `protobuf:"bytes,29,opt,name=common_http_protocol_options,json=commonHttpProtocolOptions,proto3" json:"common_http_protocol_options,omitempty"`
	HttpProtocolOptions           *protocol.Http1ProtocolOptions      `protobuf:"bytes,13,opt,name=http_protocol_options,json=httpProtocolOptions,proto3" json:"http_protocol_options,omitempty"`
	Http2ProtocolOptions          *protocol.Http2ProtocolOptions      `protobuf:"bytes,14,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	ExtensionProtocolOptions      map[string]*_struct.Struct          `protobuf:"bytes,35,rep,name=extension_protocol_options,json=extensionProtocolOptions,proto3" json:"extension_protocol_options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	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"`
	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.v2.Cluster_DnsLookupFamily" json:"dns_lookup_family,omitempty"`
	DnsResolvers                  []*address.Address                  `protobuf:"bytes,18,rep,name=dns_resolvers,json=dnsResolvers,proto3" json:"dns_resolvers,omitempty"`
	OutlierDetection              *outlier_detection.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            *address.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                     *base.TransportSocket            `protobuf:"bytes,24,opt,name=transport_socket,json=transportSocket,proto3" json:"transport_socket,omitempty"`
	Metadata                            *base.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.v2.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"`
	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_cds_3e3c13a974b77399, []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 (dst *Cluster) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster.Merge(dst, 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) 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.v2.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
}

// Deprecated: Do not use.
func (m *Cluster) GetHosts() []*address.Address {
	if m != nil {
		return m.Hosts
	}
	return nil
}

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

func (m *Cluster) GetHealthChecks() []*health_check.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() *circuit_breaker.CircuitBreakers {
	if m != nil {
		return m.CircuitBreakers
	}
	return nil
}

func (m *Cluster) GetTlsContext() *cert.UpstreamTlsContext {
	if m != nil {
		return m.TlsContext
	}
	return nil
}

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

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

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

func (m *Cluster) GetExtensionProtocolOptions() map[string]*_struct.Struct {
	if m != nil {
		return m.ExtensionProtocolOptions
	}
	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) 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() []*address.Address {
	if m != nil {
		return m.DnsResolvers
	}
	return nil
}

func (m *Cluster) GetOutlierDetection() *outlier_detection.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() *address.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() *base.TransportSocket {
	if m != nil {
		return m.TransportSocket
	}
	return nil
}

func (m *Cluster) GetMetadata() *base.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
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Cluster) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Cluster_OneofMarshaler, _Cluster_OneofUnmarshaler, _Cluster_OneofSizer, []interface{}{
		(*Cluster_Type)(nil),
		(*Cluster_ClusterType)(nil),
		(*Cluster_RingHashLbConfig_)(nil),
		(*Cluster_OriginalDstLbConfig_)(nil),
		(*Cluster_LeastRequestLbConfig_)(nil),
	}
}

func _Cluster_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Cluster)
	// cluster_discovery_type
	switch x := m.ClusterDiscoveryType.(type) {
	case *Cluster_Type:
		b.EncodeVarint(2<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Type))
	case *Cluster_ClusterType:
		b.EncodeVarint(38<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ClusterType); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Cluster.ClusterDiscoveryType has unexpected type %T", x)
	}
	// lb_config
	switch x := m.LbConfig.(type) {
	case *Cluster_RingHashLbConfig_:
		b.EncodeVarint(23<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RingHashLbConfig); err != nil {
			return err
		}
	case *Cluster_OriginalDstLbConfig_:
		b.EncodeVarint(34<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.OriginalDstLbConfig); err != nil {
			return err
		}
	case *Cluster_LeastRequestLbConfig_:
		b.EncodeVarint(37<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeastRequestLbConfig); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Cluster.LbConfig has unexpected type %T", x)
	}
	return nil
}

func _Cluster_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Cluster)
	switch tag {
	case 2: // cluster_discovery_type.type
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.ClusterDiscoveryType = &Cluster_Type{Cluster_DiscoveryType(x)}
		return true, err
	case 38: // cluster_discovery_type.cluster_type
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cluster_CustomClusterType)
		err := b.DecodeMessage(msg)
		m.ClusterDiscoveryType = &Cluster_ClusterType{msg}
		return true, err
	case 23: // lb_config.ring_hash_lb_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cluster_RingHashLbConfig)
		err := b.DecodeMessage(msg)
		m.LbConfig = &Cluster_RingHashLbConfig_{msg}
		return true, err
	case 34: // lb_config.original_dst_lb_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cluster_OriginalDstLbConfig)
		err := b.DecodeMessage(msg)
		m.LbConfig = &Cluster_OriginalDstLbConfig_{msg}
		return true, err
	case 37: // lb_config.least_request_lb_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cluster_LeastRequestLbConfig)
		err := b.DecodeMessage(msg)
		m.LbConfig = &Cluster_LeastRequestLbConfig_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Cluster_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Cluster)
	// cluster_discovery_type
	switch x := m.ClusterDiscoveryType.(type) {
	case *Cluster_Type:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Type))
	case *Cluster_ClusterType:
		s := proto.Size(x.ClusterType)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	// lb_config
	switch x := m.LbConfig.(type) {
	case *Cluster_RingHashLbConfig_:
		s := proto.Size(x.RingHashLbConfig)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Cluster_OriginalDstLbConfig_:
		s := proto.Size(x.OriginalDstLbConfig)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Cluster_LeastRequestLbConfig_:
		s := proto.Size(x.LeastRequestLbConfig)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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_cds_3e3c13a974b77399, []int{0, 0}
}
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 (dst *Cluster_CustomClusterType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CustomClusterType.Merge(dst, 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            *config_source.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_cds_3e3c13a974b77399, []int{0, 1}
}
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 (dst *Cluster_EdsClusterConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_EdsClusterConfig.Merge(dst, 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() *config_source.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.v2.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_cds_3e3c13a974b77399, []int{0, 4}
}
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 (dst *Cluster_LbSubsetConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_LbSubsetConfig.Merge(dst, 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.v2.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_cds_3e3c13a974b77399, []int{0, 4, 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 (dst *Cluster_LbSubsetConfig_LbSubsetSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_LbSubsetConfig_LbSubsetSelector.Merge(dst, 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_cds_3e3c13a974b77399, []int{0, 5}
}
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 (dst *Cluster_LeastRequestLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_LeastRequestLbConfig.Merge(dst, 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.v2.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_cds_3e3c13a974b77399, []int{0, 6}
}
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 (dst *Cluster_RingHashLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_RingHashLbConfig.Merge(dst, 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_cds_3e3c13a974b77399, []int{0, 7}
}
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 (dst *Cluster_OriginalDstLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_OriginalDstLbConfig.Merge(dst, 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 *percent.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"`
	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_cds_3e3c13a974b77399, []int{0, 8}
}
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 (dst *Cluster_CommonLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CommonLbConfig.Merge(dst, 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() *percent.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
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Cluster_CommonLbConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Cluster_CommonLbConfig_OneofMarshaler, _Cluster_CommonLbConfig_OneofUnmarshaler, _Cluster_CommonLbConfig_OneofSizer, []interface{}{
		(*Cluster_CommonLbConfig_ZoneAwareLbConfig_)(nil),
		(*Cluster_CommonLbConfig_LocalityWeightedLbConfig_)(nil),
	}
}

func _Cluster_CommonLbConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Cluster_CommonLbConfig)
	// locality_config_specifier
	switch x := m.LocalityConfigSpecifier.(type) {
	case *Cluster_CommonLbConfig_ZoneAwareLbConfig_:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ZoneAwareLbConfig); err != nil {
			return err
		}
	case *Cluster_CommonLbConfig_LocalityWeightedLbConfig_:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LocalityWeightedLbConfig); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Cluster_CommonLbConfig.LocalityConfigSpecifier has unexpected type %T", x)
	}
	return nil
}

func _Cluster_CommonLbConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Cluster_CommonLbConfig)
	switch tag {
	case 2: // locality_config_specifier.zone_aware_lb_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cluster_CommonLbConfig_ZoneAwareLbConfig)
		err := b.DecodeMessage(msg)
		m.LocalityConfigSpecifier = &Cluster_CommonLbConfig_ZoneAwareLbConfig_{msg}
		return true, err
	case 3: // locality_config_specifier.locality_weighted_lb_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Cluster_CommonLbConfig_LocalityWeightedLbConfig)
		err := b.DecodeMessage(msg)
		m.LocalityConfigSpecifier = &Cluster_CommonLbConfig_LocalityWeightedLbConfig_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Cluster_CommonLbConfig_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Cluster_CommonLbConfig)
	// locality_config_specifier
	switch x := m.LocalityConfigSpecifier.(type) {
	case *Cluster_CommonLbConfig_ZoneAwareLbConfig_:
		s := proto.Size(x.ZoneAwareLbConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Cluster_CommonLbConfig_LocalityWeightedLbConfig_:
		s := proto.Size(x.LocalityWeightedLbConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Cluster_CommonLbConfig_ZoneAwareLbConfig struct {
	RoutingEnabled       *percent.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"`
	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_cds_3e3c13a974b77399, []int{0, 8, 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 (dst *Cluster_CommonLbConfig_ZoneAwareLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CommonLbConfig_ZoneAwareLbConfig.Merge(dst, 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() *percent.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
}

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_cds_3e3c13a974b77399, []int{0, 8, 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 (dst *Cluster_CommonLbConfig_LocalityWeightedLbConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cluster_CommonLbConfig_LocalityWeightedLbConfig.Merge(dst, 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 UpstreamBindConfig struct {
	SourceAddress        *address.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_cds_3e3c13a974b77399, []int{1}
}
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 (dst *UpstreamBindConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpstreamBindConfig.Merge(dst, 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() *address.Address {
	if m != nil {
		return m.SourceAddress
	}
	return nil
}

type UpstreamConnectionOptions struct {
	TcpKeepalive         *address.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_cds_3e3c13a974b77399, []int{2}
}
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 (dst *UpstreamConnectionOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpstreamConnectionOptions.Merge(dst, 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() *address.TcpKeepalive {
	if m != nil {
		return m.TcpKeepalive
	}
	return nil
}

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

// 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 *discovery.DiscoveryRequest, opts ...grpc.CallOption) (*discovery.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.v2.ClusterDiscoveryService/StreamClusters", opts...)
	if err != nil {
		return nil, err
	}
	x := &clusterDiscoveryServiceStreamClustersClient{stream}
	return x, nil
}

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

type clusterDiscoveryServiceStreamClustersClient struct {
	grpc.ClientStream
}

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

func (x *clusterDiscoveryServiceStreamClustersClient) Recv() (*discovery.DiscoveryResponse, error) {
	m := new(discovery.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.v2.ClusterDiscoveryService/DeltaClusters", opts...)
	if err != nil {
		return nil, err
	}
	x := &clusterDiscoveryServiceDeltaClustersClient{stream}
	return x, nil
}

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

type clusterDiscoveryServiceDeltaClustersClient struct {
	grpc.ClientStream
}

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

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

func (c *clusterDiscoveryServiceClient) FetchClusters(ctx context.Context, in *discovery.DiscoveryRequest, opts ...grpc.CallOption) (*discovery.DiscoveryResponse, error) {
	out := new(discovery.DiscoveryResponse)
	err := c.cc.Invoke(ctx, "/envoy.api.v2.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, *discovery.DiscoveryRequest) (*discovery.DiscoveryResponse, error)
}

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(*discovery.DiscoveryResponse) error
	Recv() (*discovery.DiscoveryRequest, error)
	grpc.ServerStream
}

type clusterDiscoveryServiceStreamClustersServer struct {
	grpc.ServerStream
}

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

func (x *clusterDiscoveryServiceStreamClustersServer) Recv() (*discovery.DiscoveryRequest, error) {
	m := new(discovery.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(*discovery.DeltaDiscoveryResponse) error
	Recv() (*discovery.DeltaDiscoveryRequest, error)
	grpc.ServerStream
}

type clusterDiscoveryServiceDeltaClustersServer struct {
	grpc.ServerStream
}

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

func (x *clusterDiscoveryServiceDeltaClustersServer) Recv() (*discovery.DeltaDiscoveryRequest, error) {
	m := new(discovery.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(discovery.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.v2.ClusterDiscoveryService/FetchClusters",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ClusterDiscoveryServiceServer).FetchClusters(ctx, req.(*discovery.DiscoveryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ClusterDiscoveryService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "envoy.api.v2.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/v2/cds.proto",
}

func init() { proto.RegisterFile("envoy/api/v2/cds.proto", fileDescriptor_cds_3e3c13a974b77399) }

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