// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: mesh/v1alpha1/config.proto

// Configuration affecting the service mesh as a whole.

package v1alpha1

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	v1alpha3 "istio.io/api/networking/v1alpha3"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Resource describes the source of configuration
type Resource int32

const (
	// Set to only receive service entries that are generated by the platform.
	// These auto generated service entries are combination of services and endpoints
	// that are generated by a specific platform e.g. k8
	Resource_SERVICE_REGISTRY Resource = 0
)

var Resource_name = map[int32]string{
	0: "SERVICE_REGISTRY",
}

var Resource_value = map[string]int32{
	"SERVICE_REGISTRY": 0,
}

func (x Resource) String() string {
	return proto.EnumName(Resource_name, int32(x))
}

func (Resource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0}
}

type MeshConfig_IngressControllerMode int32

const (
	// Unspecified Istio ingress controller.
	MeshConfig_UNSPECIFIED MeshConfig_IngressControllerMode = 0
	// Disables Istio ingress controller.
	MeshConfig_OFF MeshConfig_IngressControllerMode = 1
	// Istio ingress controller will act on ingress resources that do not
	// contain any annotation or whose annotations match the value
	// specified in the ingress_class parameter described earlier. Use this
	// mode if Istio ingress controller will be the default ingress
	// controller for the entireKubernetes cluster.
	MeshConfig_DEFAULT MeshConfig_IngressControllerMode = 2
	// Istio ingress controller will only act on ingress resources whose
	// annotations match the value specified in the ingress_class parameter
	// described earlier. Use this mode if Istio ingress controller will be
	// a secondary ingress controller (e.g., in addition to a
	// cloud-provided ingress controller).
	MeshConfig_STRICT MeshConfig_IngressControllerMode = 3
)

var MeshConfig_IngressControllerMode_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "OFF",
	2: "DEFAULT",
	3: "STRICT",
}

var MeshConfig_IngressControllerMode_value = map[string]int32{
	"UNSPECIFIED": 0,
	"OFF":         1,
	"DEFAULT":     2,
	"STRICT":      3,
}

func (x MeshConfig_IngressControllerMode) String() string {
	return proto.EnumName(MeshConfig_IngressControllerMode_name, int32(x))
}

func (MeshConfig_IngressControllerMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 0}
}

// $hide_from_docs
type MeshConfig_AuthPolicy int32

const (
	MeshConfig_NONE       MeshConfig_AuthPolicy = 0
	MeshConfig_MUTUAL_TLS MeshConfig_AuthPolicy = 1
)

var MeshConfig_AuthPolicy_name = map[int32]string{
	0: "NONE",
	1: "MUTUAL_TLS",
}

var MeshConfig_AuthPolicy_value = map[string]int32{
	"NONE":       0,
	"MUTUAL_TLS": 1,
}

func (x MeshConfig_AuthPolicy) String() string {
	return proto.EnumName(MeshConfig_AuthPolicy_name, int32(x))
}

func (MeshConfig_AuthPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 1}
}

type MeshConfig_AccessLogEncoding int32

const (
	MeshConfig_TEXT MeshConfig_AccessLogEncoding = 0
	MeshConfig_JSON MeshConfig_AccessLogEncoding = 1
)

var MeshConfig_AccessLogEncoding_name = map[int32]string{
	0: "TEXT",
	1: "JSON",
}

var MeshConfig_AccessLogEncoding_value = map[string]int32{
	"TEXT": 0,
	"JSON": 1,
}

func (x MeshConfig_AccessLogEncoding) String() string {
	return proto.EnumName(MeshConfig_AccessLogEncoding_name, int32(x))
}

func (MeshConfig_AccessLogEncoding) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 2}
}

// Default Policy for upgrading http1.1 connections to http2.
type MeshConfig_H2UpgradePolicy int32

const (
	// Do not upgrade connections to http2.
	MeshConfig_DO_NOT_UPGRADE MeshConfig_H2UpgradePolicy = 0
	// Upgrade the connections to http2.
	MeshConfig_UPGRADE MeshConfig_H2UpgradePolicy = 1
)

var MeshConfig_H2UpgradePolicy_name = map[int32]string{
	0: "DO_NOT_UPGRADE",
	1: "UPGRADE",
}

var MeshConfig_H2UpgradePolicy_value = map[string]int32{
	"DO_NOT_UPGRADE": 0,
	"UPGRADE":        1,
}

func (x MeshConfig_H2UpgradePolicy) String() string {
	return proto.EnumName(MeshConfig_H2UpgradePolicy_name, int32(x))
}

func (MeshConfig_H2UpgradePolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 3}
}

type MeshConfig_OutboundTrafficPolicy_Mode int32

const (
	// outbound traffic will be restricted to services defined in the
	// service registry as well as those defined through ServiceEntries
	MeshConfig_OutboundTrafficPolicy_REGISTRY_ONLY MeshConfig_OutboundTrafficPolicy_Mode = 0
	// outbound traffic to unknown destinations will be allowed, in case
	// there are no services or ServiceEntries for the destination port
	MeshConfig_OutboundTrafficPolicy_ALLOW_ANY MeshConfig_OutboundTrafficPolicy_Mode = 1
)

var MeshConfig_OutboundTrafficPolicy_Mode_name = map[int32]string{
	0: "REGISTRY_ONLY",
	1: "ALLOW_ANY",
}

var MeshConfig_OutboundTrafficPolicy_Mode_value = map[string]int32{
	"REGISTRY_ONLY": 0,
	"ALLOW_ANY":     1,
}

func (x MeshConfig_OutboundTrafficPolicy_Mode) String() string {
	return proto.EnumName(MeshConfig_OutboundTrafficPolicy_Mode_name, int32(x))
}

func (MeshConfig_OutboundTrafficPolicy_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 0, 0}
}

// MeshConfig defines mesh-wide variables shared by all Envoy instances in the
// Istio service mesh.
//
// NOTE: This configuration type should be used for the low-level global
// configuration, such as component addresses and port numbers. It should not
// be used for the features of the mesh that can be scoped by service or by
// namespace. Some of the fields in the mesh config are going to be deprecated
// and replaced with several individual configuration types (for example,
// tracing configuration).
type MeshConfig struct {
	// Address of the server that will be used by the proxies for policy
	// check calls. By using different names for mixerCheckServer and
	// mixerReportServer, it is possible to have one set of Mixer servers handle
	// policy check calls while another set of Mixer servers handle telemetry
	// calls.
	//
	// NOTE: Omitting mixerCheckServer while specifying mixerReportServer is
	// equivalent to setting disablePolicyChecks to true.
	MixerCheckServer string `protobuf:"bytes,1,opt,name=mixer_check_server,json=mixerCheckServer,proto3" json:"mixerCheckServer,omitempty"`
	// Address of the server that will be used by the proxies for policy report
	// calls.
	MixerReportServer string `protobuf:"bytes,2,opt,name=mixer_report_server,json=mixerReportServer,proto3" json:"mixerReportServer,omitempty"`
	// Disable policy checks by the Mixer service. Default
	// is false, i.e. Mixer policy check is enabled by default.
	DisablePolicyChecks bool `protobuf:"varint,3,opt,name=disable_policy_checks,json=disablePolicyChecks,proto3" json:"disablePolicyChecks,omitempty"`
	// $hide_from_docs
	// Disable telemetry reporting by the Mixer service for HTTP traffic.
	// Default is false (telemetry reporting via Mixer is enabled).
	// This option provides a transition path for Istio extensibility v2.
	DisableMixerHttpReports bool `protobuf:"varint,48,opt,name=disable_mixer_http_reports,json=disableMixerHttpReports,proto3" json:"disableMixerHttpReports,omitempty"`
	// Allow all traffic in cases when the Mixer policy service cannot be reached.
	// Default is false which means the traffic is denied when the client is unable
	// to connect to Mixer.
	PolicyCheckFailOpen bool `protobuf:"varint,25,opt,name=policy_check_fail_open,json=policyCheckFailOpen,proto3" json:"policyCheckFailOpen,omitempty"`
	// Enable session affinity for Envoy Mixer reports so that calls from a proxy will
	// always target the same Mixer instance.
	SidecarToTelemetrySessionAffinity bool `protobuf:"varint,30,opt,name=sidecar_to_telemetry_session_affinity,json=sidecarToTelemetrySessionAffinity,proto3" json:"sidecarToTelemetrySessionAffinity,omitempty"`
	// Port on which Envoy should listen for incoming connections from
	// other services.
	ProxyListenPort int32 `protobuf:"varint,4,opt,name=proxy_listen_port,json=proxyListenPort,proto3" json:"proxyListenPort,omitempty"`
	// Port on which Envoy should listen for HTTP PROXY requests if set.
	ProxyHttpPort int32 `protobuf:"varint,5,opt,name=proxy_http_port,json=proxyHttpPort,proto3" json:"proxyHttpPort,omitempty"`
	// Connection timeout used by Envoy. (MUST BE >=1ms)
	ConnectTimeout *types.Duration `protobuf:"bytes,6,opt,name=connect_timeout,json=connectTimeout,proto3" json:"connectTimeout,omitempty"`
	// Automatic protocol detection uses a set of heuristics to
	// determine whether the connection is using TLS or not (on the
	// server side), as well as the application protocol being used
	// (e.g., http vs tcp). These heuristics rely on the client sending
	// the first bits of data. For server first protocols like MySQL,
	// MongoDB, etc., Envoy will timeout on the protocol detection after
	// the specified period, defaulting to non mTLS plain TCP
	// traffic. Set this field to tweak the period that Envoy will wait
	// for the client to send the first bits of data. (MUST BE >=1ms or
	// 0s to disable)
	ProtocolDetectionTimeout *types.Duration `protobuf:"bytes,42,opt,name=protocol_detection_timeout,json=protocolDetectionTimeout,proto3" json:"protocolDetectionTimeout,omitempty"`
	// If set then set SO_KEEPALIVE on the socket to enable TCP Keepalives.
	TcpKeepalive *v1alpha3.ConnectionPoolSettings_TCPSettings_TcpKeepalive `protobuf:"bytes,28,opt,name=tcp_keepalive,json=tcpKeepalive,proto3" json:"tcpKeepalive,omitempty"`
	// Class of ingress resources to be processed by Istio ingress
	// controller. This corresponds to the value of
	// "kubernetes.io/ingress.class" annotation.
	IngressClass string `protobuf:"bytes,7,opt,name=ingress_class,json=ingressClass,proto3" json:"ingressClass,omitempty"`
	// Name of the Kubernetes service used for the istio ingress controller.
	IngressService string `protobuf:"bytes,8,opt,name=ingress_service,json=ingressService,proto3" json:"ingressService,omitempty"`
	// Defines whether to use Istio ingress controller for annotated or all ingress resources.
	IngressControllerMode MeshConfig_IngressControllerMode `protobuf:"varint,9,opt,name=ingress_controller_mode,json=ingressControllerMode,proto3,enum=istio.mesh.v1alpha1.MeshConfig_IngressControllerMode" json:"ingressControllerMode,omitempty"`
	// Defines which gateway deployment to use as the Ingress controller. This field corresponds to
	// the Gateway.selector field, and will be set as `istio: INGRESS_SELECTOR`.
	// By default, `ingressgateway` is used, which will select the default IngressGateway as it has the
	// `istio: ingressgateway` labels.
	// It is recommended that this is the same value as ingress_service.
	IngressSelector string `protobuf:"bytes,52,opt,name=ingress_selector,json=ingressSelector,proto3" json:"ingressSelector,omitempty"`
	// $hide_from_docs
	AuthPolicy MeshConfig_AuthPolicy `protobuf:"varint,10,opt,name=auth_policy,json=authPolicy,proto3,enum=istio.mesh.v1alpha1.MeshConfig_AuthPolicy" json:"authPolicy,omitempty"` // Deprecated: Do not use.
	// $hide_from_docs
	RdsRefreshDelay *types.Duration `protobuf:"bytes,11,opt,name=rds_refresh_delay,json=rdsRefreshDelay,proto3" json:"rdsRefreshDelay,omitempty"` // Deprecated: Do not use.
	// Flag to control generation of trace spans and request IDs.
	// Requires a trace span collector defined in the proxy configuration.
	EnableTracing bool `protobuf:"varint,12,opt,name=enable_tracing,json=enableTracing,proto3" json:"enableTracing,omitempty"`
	// File address for the proxy access log (e.g. /dev/stdout).
	// Empty value disables access logging.
	AccessLogFile string `protobuf:"bytes,13,opt,name=access_log_file,json=accessLogFile,proto3" json:"accessLogFile,omitempty"`
	// Format for the proxy access log
	// Empty value results in proxy's default access log format
	AccessLogFormat string `protobuf:"bytes,24,opt,name=access_log_format,json=accessLogFormat,proto3" json:"accessLogFormat,omitempty"`
	// Encoding for the proxy access log (text or json).
	// Default value is text.
	AccessLogEncoding MeshConfig_AccessLogEncoding `protobuf:"varint,27,opt,name=access_log_encoding,json=accessLogEncoding,proto3,enum=istio.mesh.v1alpha1.MeshConfig_AccessLogEncoding" json:"accessLogEncoding,omitempty"`
	// This flag enables Envoy's gRPC Access Log Service.
	// See [Access Log Service](https://www.envoyproxy.io/docs/envoy/latest/api-v2/config/accesslog/v2/als.proto)
	// for details about Envoy's gRPC Access Log Service API.
	EnableEnvoyAccessLogService bool `protobuf:"varint,40,opt,name=enable_envoy_access_log_service,json=enableEnvoyAccessLogService,proto3" json:"enableEnvoyAccessLogService,omitempty"`
	// Default proxy config used by the proxy injection mechanism operating in the mesh
	// (e.g. Kubernetes admission controller)
	// In case of Kubernetes, the proxy config is applied once during the injection process,
	// and remain constant for the duration of the pod. The rest of the mesh config can be changed
	// at runtime and config gets distributed dynamically.
	DefaultConfig *ProxyConfig `protobuf:"bytes,14,opt,name=default_config,json=defaultConfig,proto3" json:"defaultConfig,omitempty"`
	// $hide_from_docs
	MixerAddress string `protobuf:"bytes,16,opt,name=mixer_address,json=mixerAddress,proto3" json:"mixerAddress,omitempty"` // Deprecated: Do not use.
	// Set the default behavior of the sidecar for handling outbound
	// traffic from the application.  If your application uses one or
	// more external services that are not known apriori, setting the
	// policy to ALLOW_ANY will cause the sidecars to route any unknown
	// traffic originating from the application to its requested
	// destination.  Users are strongly encouraged to use ServiceEntries
	// to explicitly declare any external dependencies, instead of using
	// allow_any, so that traffic to these services can be
	// monitored. Can be overridden at a Sidecar level by setting the
	// OutboundTrafficPolicy in the [Sidecar
	// API](https://istio.io/docs/reference/config/networking/sidecar/#OutboundTrafficPolicy).
	OutboundTrafficPolicy *MeshConfig_OutboundTrafficPolicy `protobuf:"bytes,17,opt,name=outbound_traffic_policy,json=outboundTrafficPolicy,proto3" json:"outboundTrafficPolicy,omitempty"`
	// Enables client side policy checks.
	EnableClientSidePolicyCheck bool `protobuf:"varint,19,opt,name=enable_client_side_policy_check,json=enableClientSidePolicyCheck,proto3" json:"enableClientSidePolicyCheck,omitempty"`
	// $hide_from_docs
	// Unix Domain Socket through which Envoy communicates with NodeAgent SDS to get key/cert for mTLS.
	// Use secret-mount files instead of SDS if set to empty.
	// @deprecated - istio agent will detect and send the path to envoy.
	SdsUdsPath string `protobuf:"bytes,20,opt,name=sds_uds_path,json=sdsUdsPath,proto3" json:"sdsUdsPath,omitempty"` // Deprecated: Do not use.
	// $hide_from_docs
	SdsRefreshDelay *types.Duration `protobuf:"bytes,21,opt,name=sds_refresh_delay,json=sdsRefreshDelay,proto3" json:"sdsRefreshDelay,omitempty"` // Deprecated: Do not use.
	// ConfigSource describes a source of configuration data for networking
	// rules, and other Istio configuration artifacts. Multiple data sources
	// can be configured for a single control plane.
	ConfigSources []*ConfigSource `protobuf:"bytes,22,rep,name=config_sources,json=configSources,proto3" json:"configSources,omitempty"`
	// This flag is used to enable mutual TLS automatically for service to service communication
	// within the mesh, default true.
	// If set to true, and a given service does not have a corresponding DestinationRule configured,
	// or its DestinationRule does not have ClientTLSSettings specified, Istio configures client side
	// TLS configuration appropriately. More specifically,
	// If the upstream authentication policy is in STRICT mode, use Istio provisioned certificate
	// for mutual TLS to connect to upstream.
	// If upstream service is in plain text mode, use plain text.
	// If the upstream authentication policy is in PERMISSIVE mode, Istio configures clients to use
	// mutual TLS when server sides are capable of accepting mutual TLS traffic.
	// If service DestinationRule exists and has ClientTLSSettings specified, that is always used instead.
	EnableAutoMtls *types.BoolValue `protobuf:"bytes,43,opt,name=enable_auto_mtls,json=enableAutoMtls,proto3" json:"enableAutoMtls,omitempty"`
	// $hide_from_docs
	// This flag is used by secret discovery service(SDS).
	// If set to true ([prerequisite](https://kubernetes.io/docs/concepts/storage/volumes/#projected)), Istio will inject volumes mount
	// for Kubernetes service account trustworthy JWT(which is available with Kubernetes 1.12 or higher), so that the Kubernetes API server
	// mounts Kubernetes service account trustworthy JWT to the Envoy container, which will be used to request key/cert eventually.
	// This isn't supported for non-Kubernetes cases.
	EnableSdsTokenMount bool `protobuf:"varint,23,opt,name=enable_sds_token_mount,json=enableSdsTokenMount,proto3" json:"enableSdsTokenMount,omitempty"`
	// $hide_from_docs
	// This flag is used by secret discovery service(SDS).
	// If set to true, Envoy will fetch a normal Kubernetes service account JWT from '/var/run/secrets/kubernetes.io/serviceaccount/token'
	// (https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#accessing-the-api-from-a-pod)
	// and pass to sds server, which will be used to request key/cert eventually.
	// If both enable_sds_token_mount and sds_use_k8s_sa_jwt are set to true, enable_sds_token_mount(trustworthy jwt) takes precedence.
	// This isn't supported for non-k8s case.
	SdsUseK8SSaJwt bool `protobuf:"varint,29,opt,name=sds_use_k8s_sa_jwt,json=sdsUseK8sSaJwt,proto3" json:"sdsUseK8sSaJwt,omitempty"`
	// The trust domain corresponds to the trust root of a system.
	// Refer to [SPIFFE-ID](https://github.com/spiffe/spiffe/blob/master/standards/SPIFFE-ID.md#21-trust-domain)
	TrustDomain string `protobuf:"bytes,26,opt,name=trust_domain,json=trustDomain,proto3" json:"trustDomain,omitempty"`
	// The trust domain aliases represent the aliases of `trust_domain`.
	// For example, if we have
	// ```yaml
	// trustDomain: td1
	// trustDomainAliases: ["td2", "td3"]
	// ```
	// Any service with the identity `td1/ns/foo/sa/a-service-account`, `td2/ns/foo/sa/a-service-account`,
	// or `td3/ns/foo/sa/a-service-account` will be treated the same in the Istio mesh.
	TrustDomainAliases []string `protobuf:"bytes,46,rep,name=trust_domain_aliases,json=trustDomainAliases,proto3" json:"trustDomainAliases,omitempty"`
	// The default value for the ServiceEntry.export_to field and services
	// imported through container registry integrations, e.g. this applies to
	// Kubernetes Service resources. The value is a list of namespace names and
	// reserved namespace aliases. The allowed namespace aliases are:
	//
	// * - All Namespaces
	// . - Current Namespace
	// ~ - No Namespace
	//
	// If not set the system will use "*" as the default value which implies that
	// services are exported to all namespaces.
	//
	// 'All namespaces' is a reasonable default for implementations that don't
	// need to restrict access or visibility of services across namespace
	// boundaries. If that requirement is present it is generally good practice to
	// make the default 'Current namespace' so that services are only visible
	// within their own namespaces by default. Operators can then expand the
	// visibility of services to other namespaces as needed. Use of 'No Namespace'
	// is expected to be rare but can have utility for deployments where
	// dependency management needs to be precise even within the scope of a single
	// namespace.
	//
	// For further discussion see the reference documentation for ServiceEntry,
	// Sidecar, and Gateway.
	DefaultServiceExportTo []string `protobuf:"bytes,31,rep,name=default_service_export_to,json=defaultServiceExportTo,proto3" json:"defaultServiceExportTo,omitempty"`
	// The default value for the VirtualService.export_to field. Has the same
	// syntax as 'default_service_export_to'.
	//
	// If not set the system will use "*" as the default value which implies that
	// virtual services are exported to all namespaces
	DefaultVirtualServiceExportTo []string `protobuf:"bytes,32,rep,name=default_virtual_service_export_to,json=defaultVirtualServiceExportTo,proto3" json:"defaultVirtualServiceExportTo,omitempty"`
	// The default value for the DestinationRule.export_to field. Has the same
	// syntax as 'default_service_export_to'.
	//
	// If not set the system will use "*" as the default value which implies that
	// destination rules are exported to all namespaces
	DefaultDestinationRuleExportTo []string `protobuf:"bytes,33,rep,name=default_destination_rule_export_to,json=defaultDestinationRuleExportTo,proto3" json:"defaultDestinationRuleExportTo,omitempty"`
	// The namespace to treat as the administrative root namespace for
	// Istio configuration. When processing a leaf namespace Istio will search for
	// declarations in that namespace first and if none are found it will
	// search in the root namespace. Any matching declaration found in the root
	// namespace is processed as if it were declared in the leaf namespace.
	//
	// The precise semantics of this processing are documented on each resource
	// type.
	RootNamespace string `protobuf:"bytes,34,opt,name=root_namespace,json=rootNamespace,proto3" json:"rootNamespace,omitempty"`
	// Locality based load balancing distribution or failover settings.
	LocalityLbSetting *v1alpha3.LocalityLoadBalancerSetting `protobuf:"bytes,35,opt,name=locality_lb_setting,json=localityLbSetting,proto3" json:"localityLbSetting,omitempty"`
	// Configures DNS refresh rate for Envoy clusters of type STRICT_DNS
	DnsRefreshRate *types.Duration `protobuf:"bytes,36,opt,name=dns_refresh_rate,json=dnsRefreshRate,proto3" json:"dnsRefreshRate,omitempty"`
	// The flag to disable report batch.
	DisableReportBatch bool `protobuf:"varint,37,opt,name=disable_report_batch,json=disableReportBatch,proto3" json:"disableReportBatch,omitempty"`
	// When disable_report_batch is false, this value specifies the maximum number
	// of requests that are batched in report. If left unspecified, the default value
	// of report_batch_max_entries == 0 will use the hardcoded defaults of
	// istio::mixerclient::ReportOptions.
	ReportBatchMaxEntries uint32 `protobuf:"varint,38,opt,name=report_batch_max_entries,json=reportBatchMaxEntries,proto3" json:"reportBatchMaxEntries,omitempty"`
	// When disable_report_batch is false, this value specifies the maximum elapsed
	// time a batched report will be sent after a user request is processed. If left
	// unspecified, the default report_batch_max_time == 0 will use the hardcoded
	// defaults of istio::mixerclient::ReportOptions.
	ReportBatchMaxTime *types.Duration `protobuf:"bytes,39,opt,name=report_batch_max_time,json=reportBatchMaxTime,proto3" json:"reportBatchMaxTime,omitempty"`
	// Specify if http1.1 connections should be upgraded to http2 by default.
	// if sidecar is installed on all pods in the mesh, then this should be set to UPGRADE.
	// If one or more services or namespaces do not have sidecar(s), then this should be set to DO_NOT_UPGRADE.
	// It can be enabled by destination using the destinationRule.trafficPolicy.connectionPool.http.h2UpgradePolicy override.
	H2UpgradePolicy MeshConfig_H2UpgradePolicy `protobuf:"varint,41,opt,name=h2_upgrade_policy,json=h2UpgradePolicy,proto3,enum=istio.mesh.v1alpha1.MeshConfig_H2UpgradePolicy" json:"h2UpgradePolicy,omitempty"`
	// Name to be used while emitting statistics for inbound clusters. The same pattern is used while computing stat prefix for
	// network filters like TCP and Redis.
	// By default, Istio emits statistics with the pattern `inbound|<port>|<port-name>|<service-FQDN>`.
	// For example `inbound|7443|grpc-reviews|reviews.prod.svc.cluster.local`. This can be used to override that pattern.
	//
	// A Pattern can be composed of various pre-defined variables. The following variables are supported.
	//
	// - `%SERVICE%` - Will be substituted with name of the service.
	// - `%SERVICE_FQDN%` - Will be substituted with FQDN of the service.
	// - `%SERVICE_PORT%` - Will be substituted with port of the service.
	// - `%SERVICE_PORT_NAME%` - Will be substituted with port name of the service.
	//
	// Following are some examples of supported patterns for reviews:
	//
	// - `%SERVICE_FQDN%_%SERVICE_PORT%` will use reviews.prod.svc.cluster.local_7443 as the stats name.
	// - `%SERVICE%` will use reviews.prod as the stats name.
	InboundClusterStatName string `protobuf:"bytes,44,opt,name=inbound_cluster_stat_name,json=inboundClusterStatName,proto3" json:"inboundClusterStatName,omitempty"`
	// Name to be used while emitting statistics for outbound clusters. The same pattern is used while computing stat prefix for
	// network filters like TCP and Redis.
	// By default, Istio emits statistics with the pattern `outbound|<port>|<subsetname>|<service-FQDN>`.
	// For example `outbound|8080|v2|reviews.prod.svc.cluster.local`. This can be used to override that pattern.
	//
	// A Pattern can be composed of various pre-defined variables. The following variables are supported.
	//
	// - `%SERVICE%` - Will be substituted with name of the service.
	// - `%SERVICE_FQDN%` - Will be substituted with FQDN of the service.
	// - `%SERVICE_PORT%` - Will be substituted with port of the service.
	// - `%SERVICE_PORT_NAME%` - Will be substituted with port name of the service.
	// - `%SUBSET_NAME%` - Will be substituted with subset.
	//
	// Following are some examples of supported patterns for reviews:
	//
	// - `%SERVICE_FQDN%_%SERVICE_PORT%` will use reviews.prod.svc.cluster.local_7443 as the stats name.
	// - `%SERVICE%` will use reviews.prod as the stats name.
	OutboundClusterStatName string `protobuf:"bytes,45,opt,name=outbound_cluster_stat_name,json=outboundClusterStatName,proto3" json:"outboundClusterStatName,omitempty"`
	// Configure the provision of certificates.
	Certificates []*Certificate `protobuf:"bytes,47,rep,name=certificates,proto3" json:"certificates,omitempty"`
	// Set configuration for Thrift protocol
	ThriftConfig *MeshConfig_ThriftConfig `protobuf:"bytes,49,opt,name=thrift_config,json=thriftConfig,proto3" json:"thriftConfig,omitempty"`
	// $hide_from_docs
	// Settings to be applied to select services.
	ServiceSettings []*MeshConfig_ServiceSettings `protobuf:"bytes,50,rep,name=service_settings,json=serviceSettings,proto3" json:"serviceSettings,omitempty"`
	// If enabled, Istio agent will merge metrics exposed by the application with metrics from Envoy
	// and Istio agent. The sidecar injection will replace `prometheus.io` annotations present on the pod
	// and redirect them towards Istio agent, which will then merge metrics of from the application with Istio metrics.
	// This relies on the annotations `prometheus.io/scrape`, `prometheus.io/port`, and
	// `prometheus.io/path` annotations.
	// If you are running a separately managed Envoy with an Istio sidecar, this may cause issues, as the metrics will collide.
	// In this case, it is recommended to disable aggregation on that deployment with the
	// `prometheus.istio.io/merge-metrics: "false"` annotation.
	// If not specified, this will be enabled by default.
	EnablePrometheusMerge *types.BoolValue `protobuf:"bytes,51,opt,name=enable_prometheus_merge,json=enablePrometheusMerge,proto3" json:"enablePrometheusMerge,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}         `json:"-"`
	XXX_unrecognized      []byte           `json:"-"`
	XXX_sizecache         int32            `json:"-"`
}

func (m *MeshConfig) Reset()         { *m = MeshConfig{} }
func (m *MeshConfig) String() string { return proto.CompactTextString(m) }
func (*MeshConfig) ProtoMessage()    {}
func (*MeshConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0}
}
func (m *MeshConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeshConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeshConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MeshConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeshConfig.Merge(m, src)
}
func (m *MeshConfig) XXX_Size() int {
	return m.Size()
}
func (m *MeshConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_MeshConfig.DiscardUnknown(m)
}

var xxx_messageInfo_MeshConfig proto.InternalMessageInfo

func (m *MeshConfig) GetMixerCheckServer() string {
	if m != nil {
		return m.MixerCheckServer
	}
	return ""
}

func (m *MeshConfig) GetMixerReportServer() string {
	if m != nil {
		return m.MixerReportServer
	}
	return ""
}

func (m *MeshConfig) GetDisablePolicyChecks() bool {
	if m != nil {
		return m.DisablePolicyChecks
	}
	return false
}

func (m *MeshConfig) GetDisableMixerHttpReports() bool {
	if m != nil {
		return m.DisableMixerHttpReports
	}
	return false
}

func (m *MeshConfig) GetPolicyCheckFailOpen() bool {
	if m != nil {
		return m.PolicyCheckFailOpen
	}
	return false
}

func (m *MeshConfig) GetSidecarToTelemetrySessionAffinity() bool {
	if m != nil {
		return m.SidecarToTelemetrySessionAffinity
	}
	return false
}

func (m *MeshConfig) GetProxyListenPort() int32 {
	if m != nil {
		return m.ProxyListenPort
	}
	return 0
}

func (m *MeshConfig) GetProxyHttpPort() int32 {
	if m != nil {
		return m.ProxyHttpPort
	}
	return 0
}

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

func (m *MeshConfig) GetProtocolDetectionTimeout() *types.Duration {
	if m != nil {
		return m.ProtocolDetectionTimeout
	}
	return nil
}

func (m *MeshConfig) GetTcpKeepalive() *v1alpha3.ConnectionPoolSettings_TCPSettings_TcpKeepalive {
	if m != nil {
		return m.TcpKeepalive
	}
	return nil
}

func (m *MeshConfig) GetIngressClass() string {
	if m != nil {
		return m.IngressClass
	}
	return ""
}

func (m *MeshConfig) GetIngressService() string {
	if m != nil {
		return m.IngressService
	}
	return ""
}

func (m *MeshConfig) GetIngressControllerMode() MeshConfig_IngressControllerMode {
	if m != nil {
		return m.IngressControllerMode
	}
	return MeshConfig_UNSPECIFIED
}

func (m *MeshConfig) GetIngressSelector() string {
	if m != nil {
		return m.IngressSelector
	}
	return ""
}

// Deprecated: Do not use.
func (m *MeshConfig) GetAuthPolicy() MeshConfig_AuthPolicy {
	if m != nil {
		return m.AuthPolicy
	}
	return MeshConfig_NONE
}

// Deprecated: Do not use.
func (m *MeshConfig) GetRdsRefreshDelay() *types.Duration {
	if m != nil {
		return m.RdsRefreshDelay
	}
	return nil
}

func (m *MeshConfig) GetEnableTracing() bool {
	if m != nil {
		return m.EnableTracing
	}
	return false
}

func (m *MeshConfig) GetAccessLogFile() string {
	if m != nil {
		return m.AccessLogFile
	}
	return ""
}

func (m *MeshConfig) GetAccessLogFormat() string {
	if m != nil {
		return m.AccessLogFormat
	}
	return ""
}

func (m *MeshConfig) GetAccessLogEncoding() MeshConfig_AccessLogEncoding {
	if m != nil {
		return m.AccessLogEncoding
	}
	return MeshConfig_TEXT
}

func (m *MeshConfig) GetEnableEnvoyAccessLogService() bool {
	if m != nil {
		return m.EnableEnvoyAccessLogService
	}
	return false
}

func (m *MeshConfig) GetDefaultConfig() *ProxyConfig {
	if m != nil {
		return m.DefaultConfig
	}
	return nil
}

// Deprecated: Do not use.
func (m *MeshConfig) GetMixerAddress() string {
	if m != nil {
		return m.MixerAddress
	}
	return ""
}

func (m *MeshConfig) GetOutboundTrafficPolicy() *MeshConfig_OutboundTrafficPolicy {
	if m != nil {
		return m.OutboundTrafficPolicy
	}
	return nil
}

func (m *MeshConfig) GetEnableClientSidePolicyCheck() bool {
	if m != nil {
		return m.EnableClientSidePolicyCheck
	}
	return false
}

// Deprecated: Do not use.
func (m *MeshConfig) GetSdsUdsPath() string {
	if m != nil {
		return m.SdsUdsPath
	}
	return ""
}

// Deprecated: Do not use.
func (m *MeshConfig) GetSdsRefreshDelay() *types.Duration {
	if m != nil {
		return m.SdsRefreshDelay
	}
	return nil
}

func (m *MeshConfig) GetConfigSources() []*ConfigSource {
	if m != nil {
		return m.ConfigSources
	}
	return nil
}

func (m *MeshConfig) GetEnableAutoMtls() *types.BoolValue {
	if m != nil {
		return m.EnableAutoMtls
	}
	return nil
}

func (m *MeshConfig) GetEnableSdsTokenMount() bool {
	if m != nil {
		return m.EnableSdsTokenMount
	}
	return false
}

func (m *MeshConfig) GetSdsUseK8SSaJwt() bool {
	if m != nil {
		return m.SdsUseK8SSaJwt
	}
	return false
}

func (m *MeshConfig) GetTrustDomain() string {
	if m != nil {
		return m.TrustDomain
	}
	return ""
}

func (m *MeshConfig) GetTrustDomainAliases() []string {
	if m != nil {
		return m.TrustDomainAliases
	}
	return nil
}

func (m *MeshConfig) GetDefaultServiceExportTo() []string {
	if m != nil {
		return m.DefaultServiceExportTo
	}
	return nil
}

func (m *MeshConfig) GetDefaultVirtualServiceExportTo() []string {
	if m != nil {
		return m.DefaultVirtualServiceExportTo
	}
	return nil
}

func (m *MeshConfig) GetDefaultDestinationRuleExportTo() []string {
	if m != nil {
		return m.DefaultDestinationRuleExportTo
	}
	return nil
}

func (m *MeshConfig) GetRootNamespace() string {
	if m != nil {
		return m.RootNamespace
	}
	return ""
}

func (m *MeshConfig) GetLocalityLbSetting() *v1alpha3.LocalityLoadBalancerSetting {
	if m != nil {
		return m.LocalityLbSetting
	}
	return nil
}

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

func (m *MeshConfig) GetDisableReportBatch() bool {
	if m != nil {
		return m.DisableReportBatch
	}
	return false
}

func (m *MeshConfig) GetReportBatchMaxEntries() uint32 {
	if m != nil {
		return m.ReportBatchMaxEntries
	}
	return 0
}

func (m *MeshConfig) GetReportBatchMaxTime() *types.Duration {
	if m != nil {
		return m.ReportBatchMaxTime
	}
	return nil
}

func (m *MeshConfig) GetH2UpgradePolicy() MeshConfig_H2UpgradePolicy {
	if m != nil {
		return m.H2UpgradePolicy
	}
	return MeshConfig_DO_NOT_UPGRADE
}

func (m *MeshConfig) GetInboundClusterStatName() string {
	if m != nil {
		return m.InboundClusterStatName
	}
	return ""
}

func (m *MeshConfig) GetOutboundClusterStatName() string {
	if m != nil {
		return m.OutboundClusterStatName
	}
	return ""
}

func (m *MeshConfig) GetCertificates() []*Certificate {
	if m != nil {
		return m.Certificates
	}
	return nil
}

func (m *MeshConfig) GetThriftConfig() *MeshConfig_ThriftConfig {
	if m != nil {
		return m.ThriftConfig
	}
	return nil
}

func (m *MeshConfig) GetServiceSettings() []*MeshConfig_ServiceSettings {
	if m != nil {
		return m.ServiceSettings
	}
	return nil
}

func (m *MeshConfig) GetEnablePrometheusMerge() *types.BoolValue {
	if m != nil {
		return m.EnablePrometheusMerge
	}
	return nil
}

type MeshConfig_OutboundTrafficPolicy struct {
	Mode                 MeshConfig_OutboundTrafficPolicy_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=istio.mesh.v1alpha1.MeshConfig_OutboundTrafficPolicy_Mode" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *MeshConfig_OutboundTrafficPolicy) Reset()         { *m = MeshConfig_OutboundTrafficPolicy{} }
func (m *MeshConfig_OutboundTrafficPolicy) String() string { return proto.CompactTextString(m) }
func (*MeshConfig_OutboundTrafficPolicy) ProtoMessage()    {}
func (*MeshConfig_OutboundTrafficPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 0}
}
func (m *MeshConfig_OutboundTrafficPolicy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeshConfig_OutboundTrafficPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeshConfig_OutboundTrafficPolicy.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MeshConfig_OutboundTrafficPolicy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeshConfig_OutboundTrafficPolicy.Merge(m, src)
}
func (m *MeshConfig_OutboundTrafficPolicy) XXX_Size() int {
	return m.Size()
}
func (m *MeshConfig_OutboundTrafficPolicy) XXX_DiscardUnknown() {
	xxx_messageInfo_MeshConfig_OutboundTrafficPolicy.DiscardUnknown(m)
}

var xxx_messageInfo_MeshConfig_OutboundTrafficPolicy proto.InternalMessageInfo

func (m *MeshConfig_OutboundTrafficPolicy) GetMode() MeshConfig_OutboundTrafficPolicy_Mode {
	if m != nil {
		return m.Mode
	}
	return MeshConfig_OutboundTrafficPolicy_REGISTRY_ONLY
}

type MeshConfig_ThriftConfig struct {
	// Specify thrift rate limit service URL. If pilot has thrift protocol support enabled,
	// this will enable the rate limit service for destinations that have matching rate
	// limit configurations.
	RateLimitUrl string `protobuf:"bytes,1,opt,name=rate_limit_url,json=rateLimitUrl,proto3" json:"rateLimitUrl,omitempty"`
	// Specify thrift rate limit service timeout, in milliseconds. Default is 50ms
	RateLimitTimeout     *types.Duration `protobuf:"bytes,2,opt,name=rate_limit_timeout,json=rateLimitTimeout,proto3" json:"rateLimitTimeout,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *MeshConfig_ThriftConfig) Reset()         { *m = MeshConfig_ThriftConfig{} }
func (m *MeshConfig_ThriftConfig) String() string { return proto.CompactTextString(m) }
func (*MeshConfig_ThriftConfig) ProtoMessage()    {}
func (*MeshConfig_ThriftConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 1}
}
func (m *MeshConfig_ThriftConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeshConfig_ThriftConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeshConfig_ThriftConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MeshConfig_ThriftConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeshConfig_ThriftConfig.Merge(m, src)
}
func (m *MeshConfig_ThriftConfig) XXX_Size() int {
	return m.Size()
}
func (m *MeshConfig_ThriftConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_MeshConfig_ThriftConfig.DiscardUnknown(m)
}

var xxx_messageInfo_MeshConfig_ThriftConfig proto.InternalMessageInfo

func (m *MeshConfig_ThriftConfig) GetRateLimitUrl() string {
	if m != nil {
		return m.RateLimitUrl
	}
	return ""
}

func (m *MeshConfig_ThriftConfig) GetRateLimitTimeout() *types.Duration {
	if m != nil {
		return m.RateLimitTimeout
	}
	return nil
}

// $hide_from_docs
// Settings to be applied to select services.
//
// For example, the following configures all services in namespace "foo" as well as the
// "bar" service in namespace "baz" to be considered cluster-local:
//
// ```yaml
// serviceSettings:
//   - settings:
//       cluster_local: true
//     hosts:
//       - "*.foo.svc.cluster.local"
//       - "bar.baz.svc.cluster.local"
// ```
type MeshConfig_ServiceSettings struct {
	// The settings to apply to the selected services.
	Settings *MeshConfig_ServiceSettings_Settings `protobuf:"bytes,1,opt,name=settings,proto3" json:"settings,omitempty"`
	// The services to which the Settings should be applied. Services are selected using the hostname
	// matching rules used by DestinationRule.
	//
	// For example: foo.bar.svc.cluster.local, *.baz.svc.cluster.local
	Hosts                []string `protobuf:"bytes,2,rep,name=hosts,proto3" json:"hosts,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MeshConfig_ServiceSettings) Reset()         { *m = MeshConfig_ServiceSettings{} }
func (m *MeshConfig_ServiceSettings) String() string { return proto.CompactTextString(m) }
func (*MeshConfig_ServiceSettings) ProtoMessage()    {}
func (*MeshConfig_ServiceSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 2}
}
func (m *MeshConfig_ServiceSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeshConfig_ServiceSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeshConfig_ServiceSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MeshConfig_ServiceSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeshConfig_ServiceSettings.Merge(m, src)
}
func (m *MeshConfig_ServiceSettings) XXX_Size() int {
	return m.Size()
}
func (m *MeshConfig_ServiceSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_MeshConfig_ServiceSettings.DiscardUnknown(m)
}

var xxx_messageInfo_MeshConfig_ServiceSettings proto.InternalMessageInfo

func (m *MeshConfig_ServiceSettings) GetSettings() *MeshConfig_ServiceSettings_Settings {
	if m != nil {
		return m.Settings
	}
	return nil
}

func (m *MeshConfig_ServiceSettings) GetHosts() []string {
	if m != nil {
		return m.Hosts
	}
	return nil
}

// Settings for the selected services.
type MeshConfig_ServiceSettings_Settings struct {
	// If true, specifies that the client and service endpoints must reside in the same cluster.
	// By default, in multi-cluster deployments, the Istio control plane assumes all service
	// endpoints to be reachable from any client in any of the clusters which are part of the
	// mesh. This configuration option limits the set of service endpoints visible to a client
	// to be cluster scoped.
	//
	// There are some common scenarios when this can be useful:
	//
	//   - A service (or group of services) is inherently local to the cluster and has local storage
	//     for that cluster. For example, the kube-system namespace (e.g. the Kube API Server).
	//   - A mesh administrator wants to slowly migrate services to Istio. They might start by first
	//     having services cluster-local and then slowly transition them to mesh-wide. They could do
	//     this service-by-service (e.g. mysvc.myns.svc.cluster.local) or as a group
	//     (e.g. *.myns.svc.cluster.local).
	//
	// By default, Istio will consider all services in the kube-system namespace to be cluster-local,
	// unless explicitly overridden here.
	ClusterLocal         bool     `protobuf:"varint,1,opt,name=cluster_local,json=clusterLocal,proto3" json:"clusterLocal,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MeshConfig_ServiceSettings_Settings) Reset()         { *m = MeshConfig_ServiceSettings_Settings{} }
func (m *MeshConfig_ServiceSettings_Settings) String() string { return proto.CompactTextString(m) }
func (*MeshConfig_ServiceSettings_Settings) ProtoMessage()    {}
func (*MeshConfig_ServiceSettings_Settings) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{0, 2, 0}
}
func (m *MeshConfig_ServiceSettings_Settings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeshConfig_ServiceSettings_Settings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeshConfig_ServiceSettings_Settings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MeshConfig_ServiceSettings_Settings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeshConfig_ServiceSettings_Settings.Merge(m, src)
}
func (m *MeshConfig_ServiceSettings_Settings) XXX_Size() int {
	return m.Size()
}
func (m *MeshConfig_ServiceSettings_Settings) XXX_DiscardUnknown() {
	xxx_messageInfo_MeshConfig_ServiceSettings_Settings.DiscardUnknown(m)
}

var xxx_messageInfo_MeshConfig_ServiceSettings_Settings proto.InternalMessageInfo

func (m *MeshConfig_ServiceSettings_Settings) GetClusterLocal() bool {
	if m != nil {
		return m.ClusterLocal
	}
	return false
}

// ConfigSource describes information about a configuration store inside a
// mesh. A single control plane instance can interact with one or more data
// sources.
type ConfigSource struct {
	// Address of the server implementing the Istio Mesh Configuration
	// protocol (MCP). Can be IP address or a fully qualified DNS name.
	// Use fs:/// to specify a file-based backend with absolute path to the directory.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// Use the tls_settings to specify the tls mode to use. If the MCP server
	// uses Istio mutual TLS and shares the root CA with Pilot, specify the TLS
	// mode as ISTIO_MUTUAL.
	TlsSettings *v1alpha3.ClientTLSSettings `protobuf:"bytes,2,opt,name=tls_settings,json=tlsSettings,proto3" json:"tlsSettings,omitempty"`
	// Describes the source of configuration, if nothing is specified default is MCP
	SubscribedResources  []Resource `protobuf:"varint,3,rep,packed,name=subscribed_resources,json=subscribedResources,proto3,enum=istio.mesh.v1alpha1.Resource" json:"subscribedResources,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ConfigSource) Reset()         { *m = ConfigSource{} }
func (m *ConfigSource) String() string { return proto.CompactTextString(m) }
func (*ConfigSource) ProtoMessage()    {}
func (*ConfigSource) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{1}
}
func (m *ConfigSource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigSource.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigSource.Merge(m, src)
}
func (m *ConfigSource) XXX_Size() int {
	return m.Size()
}
func (m *ConfigSource) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigSource.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigSource proto.InternalMessageInfo

func (m *ConfigSource) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *ConfigSource) GetTlsSettings() *v1alpha3.ClientTLSSettings {
	if m != nil {
		return m.TlsSettings
	}
	return nil
}

func (m *ConfigSource) GetSubscribedResources() []Resource {
	if m != nil {
		return m.SubscribedResources
	}
	return nil
}

// Certificate configures the provision of a certificate and its key.
// Example 1: key and cert stored in a secret
// { secretName: galley-cert
//   secretNamespace: istio-system
//   dnsNames:
//     - galley.istio-system.svc
//     - galley.mydomain.com
// }
// Example 2: key and cert stored in a directory
// { dnsNames:
//     - pilot.istio-system
//     - pilot.istio-system.svc
//     - pilot.mydomain.com
// }
type Certificate struct {
	// Name of the secret the certificate and its key will be stored into.
	// If it is empty, it will not be stored into a secret.
	// Instead, the certificate and its key will be stored into a hard-coded directory.
	SecretName string `protobuf:"bytes,1,opt,name=secret_name,json=secretName,proto3" json:"secretName,omitempty"`
	// The DNS names for the certificate. A certificate may contain
	// multiple DNS names.
	DnsNames             []string `protobuf:"bytes,2,rep,name=dns_names,json=dnsNames,proto3" json:"dnsNames,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Certificate) Reset()         { *m = Certificate{} }
func (m *Certificate) String() string { return proto.CompactTextString(m) }
func (*Certificate) ProtoMessage()    {}
func (*Certificate) Descriptor() ([]byte, []int) {
	return fileDescriptor_b5c7ece76d5d5022, []int{2}
}
func (m *Certificate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Certificate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Certificate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Certificate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Certificate.Merge(m, src)
}
func (m *Certificate) XXX_Size() int {
	return m.Size()
}
func (m *Certificate) XXX_DiscardUnknown() {
	xxx_messageInfo_Certificate.DiscardUnknown(m)
}

var xxx_messageInfo_Certificate proto.InternalMessageInfo

func (m *Certificate) GetSecretName() string {
	if m != nil {
		return m.SecretName
	}
	return ""
}

func (m *Certificate) GetDnsNames() []string {
	if m != nil {
		return m.DnsNames
	}
	return nil
}

func init() {
	proto.RegisterEnum("istio.mesh.v1alpha1.Resource", Resource_name, Resource_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_IngressControllerMode", MeshConfig_IngressControllerMode_name, MeshConfig_IngressControllerMode_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_AuthPolicy", MeshConfig_AuthPolicy_name, MeshConfig_AuthPolicy_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_AccessLogEncoding", MeshConfig_AccessLogEncoding_name, MeshConfig_AccessLogEncoding_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_H2UpgradePolicy", MeshConfig_H2UpgradePolicy_name, MeshConfig_H2UpgradePolicy_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_OutboundTrafficPolicy_Mode", MeshConfig_OutboundTrafficPolicy_Mode_name, MeshConfig_OutboundTrafficPolicy_Mode_value)
	proto.RegisterType((*MeshConfig)(nil), "istio.mesh.v1alpha1.MeshConfig")
	proto.RegisterType((*MeshConfig_OutboundTrafficPolicy)(nil), "istio.mesh.v1alpha1.MeshConfig.OutboundTrafficPolicy")
	proto.RegisterType((*MeshConfig_ThriftConfig)(nil), "istio.mesh.v1alpha1.MeshConfig.ThriftConfig")
	proto.RegisterType((*MeshConfig_ServiceSettings)(nil), "istio.mesh.v1alpha1.MeshConfig.ServiceSettings")
	proto.RegisterType((*MeshConfig_ServiceSettings_Settings)(nil), "istio.mesh.v1alpha1.MeshConfig.ServiceSettings.Settings")
	proto.RegisterType((*ConfigSource)(nil), "istio.mesh.v1alpha1.ConfigSource")
	proto.RegisterType((*Certificate)(nil), "istio.mesh.v1alpha1.Certificate")
}

func init() { proto.RegisterFile("mesh/v1alpha1/config.proto", fileDescriptor_b5c7ece76d5d5022) }

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

func (m *MeshConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeshConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.IngressSelector) > 0 {
		i -= len(m.IngressSelector)
		copy(dAtA[i:], m.IngressSelector)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.IngressSelector)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xa2
	}
	if m.EnablePrometheusMerge != nil {
		{
			size, err := m.EnablePrometheusMerge.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9a
	}
	if len(m.ServiceSettings) > 0 {
		for iNdEx := len(m.ServiceSettings) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ServiceSettings[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintConfig(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x92
		}
	}
	if m.ThriftConfig != nil {
		{
			size, err := m.ThriftConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x8a
	}
	if m.DisableMixerHttpReports {
		i--
		if m.DisableMixerHttpReports {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x80
	}
	if len(m.Certificates) > 0 {
		for iNdEx := len(m.Certificates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Certificates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintConfig(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.TrustDomainAliases) > 0 {
		for iNdEx := len(m.TrustDomainAliases) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.TrustDomainAliases[iNdEx])
			copy(dAtA[i:], m.TrustDomainAliases[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.TrustDomainAliases[iNdEx])))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.OutboundClusterStatName) > 0 {
		i -= len(m.OutboundClusterStatName)
		copy(dAtA[i:], m.OutboundClusterStatName)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.OutboundClusterStatName)))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xea
	}
	if len(m.InboundClusterStatName) > 0 {
		i -= len(m.InboundClusterStatName)
		copy(dAtA[i:], m.InboundClusterStatName)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.InboundClusterStatName)))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe2
	}
	if m.EnableAutoMtls != nil {
		{
			size, err := m.EnableAutoMtls.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xda
	}
	if m.ProtocolDetectionTimeout != nil {
		{
			size, err := m.ProtocolDetectionTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd2
	}
	if m.H2UpgradePolicy != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.H2UpgradePolicy))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc8
	}
	if m.EnableEnvoyAccessLogService {
		i--
		if m.EnableEnvoyAccessLogService {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc0
	}
	if m.ReportBatchMaxTime != nil {
		{
			size, err := m.ReportBatchMaxTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xba
	}
	if m.ReportBatchMaxEntries != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ReportBatchMaxEntries))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xb0
	}
	if m.DisableReportBatch {
		i--
		if m.DisableReportBatch {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa8
	}
	if m.DnsRefreshRate != nil {
		{
			size, err := m.DnsRefreshRate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa2
	}
	if m.LocalityLbSetting != nil {
		{
			size, err := m.LocalityLbSetting.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x9a
	}
	if len(m.RootNamespace) > 0 {
		i -= len(m.RootNamespace)
		copy(dAtA[i:], m.RootNamespace)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.RootNamespace)))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x92
	}
	if len(m.DefaultDestinationRuleExportTo) > 0 {
		for iNdEx := len(m.DefaultDestinationRuleExportTo) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DefaultDestinationRuleExportTo[iNdEx])
			copy(dAtA[i:], m.DefaultDestinationRuleExportTo[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.DefaultDestinationRuleExportTo[iNdEx])))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.DefaultVirtualServiceExportTo) > 0 {
		for iNdEx := len(m.DefaultVirtualServiceExportTo) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DefaultVirtualServiceExportTo[iNdEx])
			copy(dAtA[i:], m.DefaultVirtualServiceExportTo[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.DefaultVirtualServiceExportTo[iNdEx])))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.DefaultServiceExportTo) > 0 {
		for iNdEx := len(m.DefaultServiceExportTo) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DefaultServiceExportTo[iNdEx])
			copy(dAtA[i:], m.DefaultServiceExportTo[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.DefaultServiceExportTo[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xfa
		}
	}
	if m.SidecarToTelemetrySessionAffinity {
		i--
		if m.SidecarToTelemetrySessionAffinity {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf0
	}
	if m.SdsUseK8SSaJwt {
		i--
		if m.SdsUseK8SSaJwt {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe8
	}
	if m.TcpKeepalive != nil {
		{
			size, err := m.TcpKeepalive.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe2
	}
	if m.AccessLogEncoding != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.AccessLogEncoding))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd8
	}
	if len(m.TrustDomain) > 0 {
		i -= len(m.TrustDomain)
		copy(dAtA[i:], m.TrustDomain)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.TrustDomain)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	if m.PolicyCheckFailOpen {
		i--
		if m.PolicyCheckFailOpen {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	if len(m.AccessLogFormat) > 0 {
		i -= len(m.AccessLogFormat)
		copy(dAtA[i:], m.AccessLogFormat)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.AccessLogFormat)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc2
	}
	if m.EnableSdsTokenMount {
		i--
		if m.EnableSdsTokenMount {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if len(m.ConfigSources) > 0 {
		for iNdEx := len(m.ConfigSources) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ConfigSources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintConfig(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if m.SdsRefreshDelay != nil {
		{
			size, err := m.SdsRefreshDelay.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if len(m.SdsUdsPath) > 0 {
		i -= len(m.SdsUdsPath)
		copy(dAtA[i:], m.SdsUdsPath)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.SdsUdsPath)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if m.EnableClientSidePolicyCheck {
		i--
		if m.EnableClientSidePolicyCheck {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.OutboundTrafficPolicy != nil {
		{
			size, err := m.OutboundTrafficPolicy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.MixerAddress) > 0 {
		i -= len(m.MixerAddress)
		copy(dAtA[i:], m.MixerAddress)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.MixerAddress)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.DefaultConfig != nil {
		{
			size, err := m.DefaultConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if len(m.AccessLogFile) > 0 {
		i -= len(m.AccessLogFile)
		copy(dAtA[i:], m.AccessLogFile)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.AccessLogFile)))
		i--
		dAtA[i] = 0x6a
	}
	if m.EnableTracing {
		i--
		if m.EnableTracing {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.RdsRefreshDelay != nil {
		{
			size, err := m.RdsRefreshDelay.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.AuthPolicy != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.AuthPolicy))
		i--
		dAtA[i] = 0x50
	}
	if m.IngressControllerMode != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.IngressControllerMode))
		i--
		dAtA[i] = 0x48
	}
	if len(m.IngressService) > 0 {
		i -= len(m.IngressService)
		copy(dAtA[i:], m.IngressService)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.IngressService)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.IngressClass) > 0 {
		i -= len(m.IngressClass)
		copy(dAtA[i:], m.IngressClass)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.IngressClass)))
		i--
		dAtA[i] = 0x3a
	}
	if m.ConnectTimeout != nil {
		{
			size, err := m.ConnectTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ProxyHttpPort != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ProxyHttpPort))
		i--
		dAtA[i] = 0x28
	}
	if m.ProxyListenPort != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ProxyListenPort))
		i--
		dAtA[i] = 0x20
	}
	if m.DisablePolicyChecks {
		i--
		if m.DisablePolicyChecks {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.MixerReportServer) > 0 {
		i -= len(m.MixerReportServer)
		copy(dAtA[i:], m.MixerReportServer)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.MixerReportServer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.MixerCheckServer) > 0 {
		i -= len(m.MixerCheckServer)
		copy(dAtA[i:], m.MixerCheckServer)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.MixerCheckServer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MeshConfig_OutboundTrafficPolicy) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig_OutboundTrafficPolicy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeshConfig_OutboundTrafficPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mode != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MeshConfig_ThriftConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig_ThriftConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeshConfig_ThriftConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RateLimitTimeout != nil {
		{
			size, err := m.RateLimitTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.RateLimitUrl) > 0 {
		i -= len(m.RateLimitUrl)
		copy(dAtA[i:], m.RateLimitUrl)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.RateLimitUrl)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MeshConfig_ServiceSettings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig_ServiceSettings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeshConfig_ServiceSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Hosts) > 0 {
		for iNdEx := len(m.Hosts) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Hosts[iNdEx])
			copy(dAtA[i:], m.Hosts[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.Hosts[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Settings != nil {
		{
			size, err := m.Settings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MeshConfig_ServiceSettings_Settings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig_ServiceSettings_Settings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeshConfig_ServiceSettings_Settings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ClusterLocal {
		i--
		if m.ClusterLocal {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ConfigSource) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigSource) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.SubscribedResources) > 0 {
		dAtA17 := make([]byte, len(m.SubscribedResources)*10)
		var j16 int
		for _, num := range m.SubscribedResources {
			for num >= 1<<7 {
				dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j16++
			}
			dAtA17[j16] = uint8(num)
			j16++
		}
		i -= j16
		copy(dAtA[i:], dAtA17[:j16])
		i = encodeVarintConfig(dAtA, i, uint64(j16))
		i--
		dAtA[i] = 0x1a
	}
	if m.TlsSettings != nil {
		{
			size, err := m.TlsSettings.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Certificate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Certificate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Certificate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DnsNames) > 0 {
		for iNdEx := len(m.DnsNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DnsNames[iNdEx])
			copy(dAtA[i:], m.DnsNames[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.DnsNames[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.SecretName) > 0 {
		i -= len(m.SecretName)
		copy(dAtA[i:], m.SecretName)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.SecretName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
	offset -= sovConfig(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MeshConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MixerCheckServer)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.MixerReportServer)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.DisablePolicyChecks {
		n += 2
	}
	if m.ProxyListenPort != 0 {
		n += 1 + sovConfig(uint64(m.ProxyListenPort))
	}
	if m.ProxyHttpPort != 0 {
		n += 1 + sovConfig(uint64(m.ProxyHttpPort))
	}
	if m.ConnectTimeout != nil {
		l = m.ConnectTimeout.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.IngressClass)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.IngressService)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.IngressControllerMode != 0 {
		n += 1 + sovConfig(uint64(m.IngressControllerMode))
	}
	if m.AuthPolicy != 0 {
		n += 1 + sovConfig(uint64(m.AuthPolicy))
	}
	if m.RdsRefreshDelay != nil {
		l = m.RdsRefreshDelay.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.EnableTracing {
		n += 2
	}
	l = len(m.AccessLogFile)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.DefaultConfig != nil {
		l = m.DefaultConfig.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.MixerAddress)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.OutboundTrafficPolicy != nil {
		l = m.OutboundTrafficPolicy.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.EnableClientSidePolicyCheck {
		n += 3
	}
	l = len(m.SdsUdsPath)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.SdsRefreshDelay != nil {
		l = m.SdsRefreshDelay.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if len(m.ConfigSources) > 0 {
		for _, e := range m.ConfigSources {
			l = e.Size()
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if m.EnableSdsTokenMount {
		n += 3
	}
	l = len(m.AccessLogFormat)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.PolicyCheckFailOpen {
		n += 3
	}
	l = len(m.TrustDomain)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.AccessLogEncoding != 0 {
		n += 2 + sovConfig(uint64(m.AccessLogEncoding))
	}
	if m.TcpKeepalive != nil {
		l = m.TcpKeepalive.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.SdsUseK8SSaJwt {
		n += 3
	}
	if m.SidecarToTelemetrySessionAffinity {
		n += 3
	}
	if len(m.DefaultServiceExportTo) > 0 {
		for _, s := range m.DefaultServiceExportTo {
			l = len(s)
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if len(m.DefaultVirtualServiceExportTo) > 0 {
		for _, s := range m.DefaultVirtualServiceExportTo {
			l = len(s)
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if len(m.DefaultDestinationRuleExportTo) > 0 {
		for _, s := range m.DefaultDestinationRuleExportTo {
			l = len(s)
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	l = len(m.RootNamespace)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.LocalityLbSetting != nil {
		l = m.LocalityLbSetting.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.DnsRefreshRate != nil {
		l = m.DnsRefreshRate.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.DisableReportBatch {
		n += 3
	}
	if m.ReportBatchMaxEntries != 0 {
		n += 2 + sovConfig(uint64(m.ReportBatchMaxEntries))
	}
	if m.ReportBatchMaxTime != nil {
		l = m.ReportBatchMaxTime.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.EnableEnvoyAccessLogService {
		n += 3
	}
	if m.H2UpgradePolicy != 0 {
		n += 2 + sovConfig(uint64(m.H2UpgradePolicy))
	}
	if m.ProtocolDetectionTimeout != nil {
		l = m.ProtocolDetectionTimeout.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.EnableAutoMtls != nil {
		l = m.EnableAutoMtls.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	l = len(m.InboundClusterStatName)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	l = len(m.OutboundClusterStatName)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if len(m.TrustDomainAliases) > 0 {
		for _, s := range m.TrustDomainAliases {
			l = len(s)
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if len(m.Certificates) > 0 {
		for _, e := range m.Certificates {
			l = e.Size()
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if m.DisableMixerHttpReports {
		n += 3
	}
	if m.ThriftConfig != nil {
		l = m.ThriftConfig.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if len(m.ServiceSettings) > 0 {
		for _, e := range m.ServiceSettings {
			l = e.Size()
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if m.EnablePrometheusMerge != nil {
		l = m.EnablePrometheusMerge.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	l = len(m.IngressSelector)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MeshConfig_OutboundTrafficPolicy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mode != 0 {
		n += 1 + sovConfig(uint64(m.Mode))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MeshConfig_ThriftConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RateLimitUrl)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.RateLimitTimeout != nil {
		l = m.RateLimitTimeout.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MeshConfig_ServiceSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Settings != nil {
		l = m.Settings.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if len(m.Hosts) > 0 {
		for _, s := range m.Hosts {
			l = len(s)
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MeshConfig_ServiceSettings_Settings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ClusterLocal {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ConfigSource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.TlsSettings != nil {
		l = m.TlsSettings.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if len(m.SubscribedResources) > 0 {
		l = 0
		for _, e := range m.SubscribedResources {
			l += sovConfig(uint64(e))
		}
		n += 1 + sovConfig(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Certificate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SecretName)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if len(m.DnsNames) > 0 {
		for _, s := range m.DnsNames {
			l = len(s)
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovConfig(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozConfig(x uint64) (n int) {
	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MeshConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MeshConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeshConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerCheckServer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixerCheckServer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerReportServer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixerReportServer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisablePolicyChecks", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisablePolicyChecks = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProxyListenPort", wireType)
			}
			m.ProxyListenPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProxyListenPort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProxyHttpPort", wireType)
			}
			m.ProxyHttpPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProxyHttpPort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConnectTimeout == nil {
				m.ConnectTimeout = &types.Duration{}
			}
			if err := m.ConnectTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressClass", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IngressClass = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressService", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IngressService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressControllerMode", wireType)
			}
			m.IngressControllerMode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IngressControllerMode |= MeshConfig_IngressControllerMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthPolicy", wireType)
			}
			m.AuthPolicy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthPolicy |= MeshConfig_AuthPolicy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RdsRefreshDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RdsRefreshDelay == nil {
				m.RdsRefreshDelay = &types.Duration{}
			}
			if err := m.RdsRefreshDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableTracing", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableTracing = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogFile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessLogFile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DefaultConfig == nil {
				m.DefaultConfig = &ProxyConfig{}
			}
			if err := m.DefaultConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundTrafficPolicy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OutboundTrafficPolicy == nil {
				m.OutboundTrafficPolicy = &MeshConfig_OutboundTrafficPolicy{}
			}
			if err := m.OutboundTrafficPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableClientSidePolicyCheck", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableClientSidePolicyCheck = bool(v != 0)
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdsUdsPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SdsUdsPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdsRefreshDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SdsRefreshDelay == nil {
				m.SdsRefreshDelay = &types.Duration{}
			}
			if err := m.SdsRefreshDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigSources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigSources = append(m.ConfigSources, &ConfigSource{})
			if err := m.ConfigSources[len(m.ConfigSources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableSdsTokenMount", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableSdsTokenMount = bool(v != 0)
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogFormat", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessLogFormat = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PolicyCheckFailOpen", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PolicyCheckFailOpen = bool(v != 0)
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustDomain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustDomain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 27:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogEncoding", wireType)
			}
			m.AccessLogEncoding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AccessLogEncoding |= MeshConfig_AccessLogEncoding(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TcpKeepalive", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TcpKeepalive == nil {
				m.TcpKeepalive = &v1alpha3.ConnectionPoolSettings_TCPSettings_TcpKeepalive{}
			}
			if err := m.TcpKeepalive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdsUseK8SSaJwt", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SdsUseK8SSaJwt = bool(v != 0)
		case 30:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SidecarToTelemetrySessionAffinity", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SidecarToTelemetrySessionAffinity = bool(v != 0)
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultServiceExportTo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultServiceExportTo = append(m.DefaultServiceExportTo, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultVirtualServiceExportTo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultVirtualServiceExportTo = append(m.DefaultVirtualServiceExportTo, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultDestinationRuleExportTo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultDestinationRuleExportTo = append(m.DefaultDestinationRuleExportTo, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootNamespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootNamespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalityLbSetting", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LocalityLbSetting == nil {
				m.LocalityLbSetting = &v1alpha3.LocalityLoadBalancerSetting{}
			}
			if err := m.LocalityLbSetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DnsRefreshRate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DnsRefreshRate == nil {
				m.DnsRefreshRate = &types.Duration{}
			}
			if err := m.DnsRefreshRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 37:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableReportBatch", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableReportBatch = bool(v != 0)
		case 38:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportBatchMaxEntries", wireType)
			}
			m.ReportBatchMaxEntries = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReportBatchMaxEntries |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 39:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportBatchMaxTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReportBatchMaxTime == nil {
				m.ReportBatchMaxTime = &types.Duration{}
			}
			if err := m.ReportBatchMaxTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 40:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableEnvoyAccessLogService", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableEnvoyAccessLogService = bool(v != 0)
		case 41:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field H2UpgradePolicy", wireType)
			}
			m.H2UpgradePolicy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.H2UpgradePolicy |= MeshConfig_H2UpgradePolicy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 42:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProtocolDetectionTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProtocolDetectionTimeout == nil {
				m.ProtocolDetectionTimeout = &types.Duration{}
			}
			if err := m.ProtocolDetectionTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 43:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableAutoMtls", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EnableAutoMtls == nil {
				m.EnableAutoMtls = &types.BoolValue{}
			}
			if err := m.EnableAutoMtls.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 44:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InboundClusterStatName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InboundClusterStatName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 45:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundClusterStatName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutboundClusterStatName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 46:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustDomainAliases", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustDomainAliases = append(m.TrustDomainAliases, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 47:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Certificates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Certificates = append(m.Certificates, &Certificate{})
			if err := m.Certificates[len(m.Certificates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 48:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableMixerHttpReports", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableMixerHttpReports = bool(v != 0)
		case 49:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThriftConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ThriftConfig == nil {
				m.ThriftConfig = &MeshConfig_ThriftConfig{}
			}
			if err := m.ThriftConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 50:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceSettings = append(m.ServiceSettings, &MeshConfig_ServiceSettings{})
			if err := m.ServiceSettings[len(m.ServiceSettings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 51:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnablePrometheusMerge", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EnablePrometheusMerge == nil {
				m.EnablePrometheusMerge = &types.BoolValue{}
			}
			if err := m.EnablePrometheusMerge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 52:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressSelector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IngressSelector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeshConfig_OutboundTrafficPolicy) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutboundTrafficPolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutboundTrafficPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= MeshConfig_OutboundTrafficPolicy_Mode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeshConfig_ThriftConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ThriftConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThriftConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RateLimitUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RateLimitUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RateLimitTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RateLimitTimeout == nil {
				m.RateLimitTimeout = &types.Duration{}
			}
			if err := m.RateLimitTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeshConfig_ServiceSettings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Settings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Settings == nil {
				m.Settings = &MeshConfig_ServiceSettings_Settings{}
			}
			if err := m.Settings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeshConfig_ServiceSettings_Settings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Settings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Settings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterLocal", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ClusterLocal = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigSource) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigSource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigSource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TlsSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TlsSettings == nil {
				m.TlsSettings = &v1alpha3.ClientTLSSettings{}
			}
			if err := m.TlsSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v Resource
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowConfig
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= Resource(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.SubscribedResources = append(m.SubscribedResources, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowConfig
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthConfig
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthConfig
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.SubscribedResources) == 0 {
					m.SubscribedResources = make([]Resource, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v Resource
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowConfig
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= Resource(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.SubscribedResources = append(m.SubscribedResources, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscribedResources", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Certificate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Certificate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Certificate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecretName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DnsNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DnsNames = append(m.DnsNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipConfig(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthConfig
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthConfig
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowConfig
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipConfig(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthConfig
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthConfig = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfig   = fmt.Errorf("proto: integer overflow")
)