bootstrap.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: envoy/config/bootstrap/v2/bootstrap.proto

package envoy_config_bootstrap_v2

import (
	fmt "fmt"
	v22 "github.com/datawire/ambassador/pkg/api/envoy/api/v2"
	auth "github.com/datawire/ambassador/pkg/api/envoy/api/v2/auth"
	core "github.com/datawire/ambassador/pkg/api/envoy/api/v2/core"
	v2 "github.com/datawire/ambassador/pkg/api/envoy/config/metrics/v2"
	v2alpha "github.com/datawire/ambassador/pkg/api/envoy/config/overload/v2alpha"
	v21 "github.com/datawire/ambassador/pkg/api/envoy/config/trace/v2"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	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

// Bootstrap :ref:`configuration overview <config_overview_v2_bootstrap>`.
// [#next-free-field: 20]
type Bootstrap struct {
	// Node identity to present to the management server and for instance
	// identification purposes (e.g. in generated headers).
	Node *core.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	// Statically specified resources.
	StaticResources *Bootstrap_StaticResources `protobuf:"bytes,2,opt,name=static_resources,json=staticResources,proto3" json:"static_resources,omitempty"`
	// xDS configuration sources.
	DynamicResources *Bootstrap_DynamicResources `protobuf:"bytes,3,opt,name=dynamic_resources,json=dynamicResources,proto3" json:"dynamic_resources,omitempty"`
	// Configuration for the cluster manager which owns all upstream clusters
	// within the server.
	ClusterManager *ClusterManager `protobuf:"bytes,4,opt,name=cluster_manager,json=clusterManager,proto3" json:"cluster_manager,omitempty"`
	// Health discovery service config option.
	// (:ref:`core.ApiConfigSource <envoy_api_msg_core.ApiConfigSource>`)
	HdsConfig *core.ApiConfigSource `protobuf:"bytes,14,opt,name=hds_config,json=hdsConfig,proto3" json:"hds_config,omitempty"`
	// Optional file system path to search for startup flag files.
	FlagsPath string `protobuf:"bytes,5,opt,name=flags_path,json=flagsPath,proto3" json:"flags_path,omitempty"`
	// Optional set of stats sinks.
	StatsSinks []*v2.StatsSink `protobuf:"bytes,6,rep,name=stats_sinks,json=statsSinks,proto3" json:"stats_sinks,omitempty"`
	// Configuration for internal processing of stats.
	StatsConfig *v2.StatsConfig `protobuf:"bytes,13,opt,name=stats_config,json=statsConfig,proto3" json:"stats_config,omitempty"`
	// Optional duration between flushes to configured stats sinks. For
	// performance reasons Envoy latches counters and only flushes counters and
	// gauges at a periodic interval. If not specified the default is 5000ms (5
	// seconds).
	// Duration must be at least 1ms and at most 5 min.
	StatsFlushInterval *types.Duration `protobuf:"bytes,7,opt,name=stats_flush_interval,json=statsFlushInterval,proto3" json:"stats_flush_interval,omitempty"`
	// Optional watchdog configuration.
	Watchdog *Watchdog `protobuf:"bytes,8,opt,name=watchdog,proto3" json:"watchdog,omitempty"`
	// Configuration for an external tracing provider. If not specified, no
	// tracing will be performed.
	Tracing *v21.Tracing `protobuf:"bytes,9,opt,name=tracing,proto3" json:"tracing,omitempty"`
	// Configuration for the runtime configuration provider (deprecated). If not
	// specified, a “null” provider will be used which will result in all defaults
	// being used.
	Runtime *Runtime `protobuf:"bytes,11,opt,name=runtime,proto3" json:"runtime,omitempty"` // Deprecated: Do not use.
	// Configuration for the runtime configuration provider. If not
	// specified, a “null” provider will be used which will result in all defaults
	// being used.
	LayeredRuntime *LayeredRuntime `protobuf:"bytes,17,opt,name=layered_runtime,json=layeredRuntime,proto3" json:"layered_runtime,omitempty"`
	// Configuration for the local administration HTTP server.
	Admin *Admin `protobuf:"bytes,12,opt,name=admin,proto3" json:"admin,omitempty"`
	// Optional overload manager configuration.
	OverloadManager *v2alpha.OverloadManager `protobuf:"bytes,15,opt,name=overload_manager,json=overloadManager,proto3" json:"overload_manager,omitempty"`
	// Enable :ref:`stats for event dispatcher <operations_performance>`, defaults to false.
	// Note that this records a value for each iteration of the event loop on every thread. This
	// should normally be minimal overhead, but when using
	// :ref:`statsd <envoy_api_msg_config.metrics.v2.StatsdSink>`, it will send each observed value
	// over the wire individually because the statsd protocol doesn't have any way to represent a
	// histogram summary. Be aware that this can be a very large volume of data.
	EnableDispatcherStats bool `protobuf:"varint,16,opt,name=enable_dispatcher_stats,json=enableDispatcherStats,proto3" json:"enable_dispatcher_stats,omitempty"`
	// Optional string which will be used in lieu of x-envoy in prefixing headers.
	//
	// For example, if this string is present and set to X-Foo, then x-envoy-retry-on will be
	// transformed into x-foo-retry-on etc.
	//
	// Note this applies to the headers Envoy will generate, the headers Envoy will sanitize, and the
	// headers Envoy will trust for core code and core extensions only. Be VERY careful making
	// changes to this string, especially in multi-layer Envoy deployments or deployments using
	// extensions which are not upstream.
	HeaderPrefix string `protobuf:"bytes,18,opt,name=header_prefix,json=headerPrefix,proto3" json:"header_prefix,omitempty"`
	// Optional proxy version which will be used to set the value of :ref:`server.version statistic
	// <server_statistics>` if specified. Envoy will not process this value, it will be sent as is to
	// :ref:<stats sinks <envoy_api_msg_config.metrics.v2.StatsSink>.
	StatsServerVersionOverride *types.UInt64Value `protobuf:"bytes,19,opt,name=stats_server_version_override,json=statsServerVersionOverride,proto3" json:"stats_server_version_override,omitempty"`
	XXX_NoUnkeyedLiteral       struct{}           `json:"-"`
	XXX_unrecognized           []byte             `json:"-"`
	XXX_sizecache              int32              `json:"-"`
}

func (m *Bootstrap) Reset()         { *m = Bootstrap{} }
func (m *Bootstrap) String() string { return proto.CompactTextString(m) }
func (*Bootstrap) ProtoMessage()    {}
func (*Bootstrap) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{0}
}
func (m *Bootstrap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Bootstrap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Bootstrap.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 *Bootstrap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bootstrap.Merge(m, src)
}
func (m *Bootstrap) XXX_Size() int {
	return m.Size()
}
func (m *Bootstrap) XXX_DiscardUnknown() {
	xxx_messageInfo_Bootstrap.DiscardUnknown(m)
}

var xxx_messageInfo_Bootstrap proto.InternalMessageInfo

func (m *Bootstrap) GetNode() *core.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *Bootstrap) GetStaticResources() *Bootstrap_StaticResources {
	if m != nil {
		return m.StaticResources
	}
	return nil
}

func (m *Bootstrap) GetDynamicResources() *Bootstrap_DynamicResources {
	if m != nil {
		return m.DynamicResources
	}
	return nil
}

func (m *Bootstrap) GetClusterManager() *ClusterManager {
	if m != nil {
		return m.ClusterManager
	}
	return nil
}

func (m *Bootstrap) GetHdsConfig() *core.ApiConfigSource {
	if m != nil {
		return m.HdsConfig
	}
	return nil
}

func (m *Bootstrap) GetFlagsPath() string {
	if m != nil {
		return m.FlagsPath
	}
	return ""
}

func (m *Bootstrap) GetStatsSinks() []*v2.StatsSink {
	if m != nil {
		return m.StatsSinks
	}
	return nil
}

func (m *Bootstrap) GetStatsConfig() *v2.StatsConfig {
	if m != nil {
		return m.StatsConfig
	}
	return nil
}

func (m *Bootstrap) GetStatsFlushInterval() *types.Duration {
	if m != nil {
		return m.StatsFlushInterval
	}
	return nil
}

func (m *Bootstrap) GetWatchdog() *Watchdog {
	if m != nil {
		return m.Watchdog
	}
	return nil
}

func (m *Bootstrap) GetTracing() *v21.Tracing {
	if m != nil {
		return m.Tracing
	}
	return nil
}

// Deprecated: Do not use.
func (m *Bootstrap) GetRuntime() *Runtime {
	if m != nil {
		return m.Runtime
	}
	return nil
}

func (m *Bootstrap) GetLayeredRuntime() *LayeredRuntime {
	if m != nil {
		return m.LayeredRuntime
	}
	return nil
}

func (m *Bootstrap) GetAdmin() *Admin {
	if m != nil {
		return m.Admin
	}
	return nil
}

func (m *Bootstrap) GetOverloadManager() *v2alpha.OverloadManager {
	if m != nil {
		return m.OverloadManager
	}
	return nil
}

func (m *Bootstrap) GetEnableDispatcherStats() bool {
	if m != nil {
		return m.EnableDispatcherStats
	}
	return false
}

func (m *Bootstrap) GetHeaderPrefix() string {
	if m != nil {
		return m.HeaderPrefix
	}
	return ""
}

func (m *Bootstrap) GetStatsServerVersionOverride() *types.UInt64Value {
	if m != nil {
		return m.StatsServerVersionOverride
	}
	return nil
}

type Bootstrap_StaticResources struct {
	// Static :ref:`Listeners <envoy_api_msg_Listener>`. These listeners are
	// available regardless of LDS configuration.
	Listeners []*v22.Listener `protobuf:"bytes,1,rep,name=listeners,proto3" json:"listeners,omitempty"`
	// If a network based configuration source is specified for :ref:`cds_config
	// <envoy_api_field_config.bootstrap.v2.Bootstrap.DynamicResources.cds_config>`, it's necessary
	// to have some initial cluster definitions available to allow Envoy to know
	// how to speak to the management server. These cluster definitions may not
	// use :ref:`EDS <arch_overview_dynamic_config_eds>` (i.e. they should be static
	// IP or DNS-based).
	Clusters []*v22.Cluster `protobuf:"bytes,2,rep,name=clusters,proto3" json:"clusters,omitempty"`
	// These static secrets can be used by :ref:`SdsSecretConfig
	// <envoy_api_msg_auth.SdsSecretConfig>`
	Secrets              []*auth.Secret `protobuf:"bytes,3,rep,name=secrets,proto3" json:"secrets,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Bootstrap_StaticResources) Reset()         { *m = Bootstrap_StaticResources{} }
func (m *Bootstrap_StaticResources) String() string { return proto.CompactTextString(m) }
func (*Bootstrap_StaticResources) ProtoMessage()    {}
func (*Bootstrap_StaticResources) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{0, 0}
}
func (m *Bootstrap_StaticResources) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Bootstrap_StaticResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Bootstrap_StaticResources.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 *Bootstrap_StaticResources) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bootstrap_StaticResources.Merge(m, src)
}
func (m *Bootstrap_StaticResources) XXX_Size() int {
	return m.Size()
}
func (m *Bootstrap_StaticResources) XXX_DiscardUnknown() {
	xxx_messageInfo_Bootstrap_StaticResources.DiscardUnknown(m)
}

var xxx_messageInfo_Bootstrap_StaticResources proto.InternalMessageInfo

func (m *Bootstrap_StaticResources) GetListeners() []*v22.Listener {
	if m != nil {
		return m.Listeners
	}
	return nil
}

func (m *Bootstrap_StaticResources) GetClusters() []*v22.Cluster {
	if m != nil {
		return m.Clusters
	}
	return nil
}

func (m *Bootstrap_StaticResources) GetSecrets() []*auth.Secret {
	if m != nil {
		return m.Secrets
	}
	return nil
}

type Bootstrap_DynamicResources struct {
	// All :ref:`Listeners <envoy_api_msg_Listener>` are provided by a single
	// :ref:`LDS <arch_overview_dynamic_config_lds>` configuration source.
	LdsConfig *core.ConfigSource `protobuf:"bytes,1,opt,name=lds_config,json=ldsConfig,proto3" json:"lds_config,omitempty"`
	// All post-bootstrap :ref:`Cluster <envoy_api_msg_Cluster>` definitions are
	// provided by a single :ref:`CDS <arch_overview_dynamic_config_cds>`
	// configuration source.
	CdsConfig *core.ConfigSource `protobuf:"bytes,2,opt,name=cds_config,json=cdsConfig,proto3" json:"cds_config,omitempty"`
	// A single :ref:`ADS <config_overview_v2_ads>` source may be optionally
	// specified. This must have :ref:`api_type
	// <envoy_api_field_core.ApiConfigSource.api_type>` :ref:`GRPC
	// <envoy_api_enum_value_core.ApiConfigSource.ApiType.GRPC>`. Only
	// :ref:`ConfigSources <envoy_api_msg_core.ConfigSource>` that have
	// the :ref:`ads <envoy_api_field_core.ConfigSource.ads>` field set will be
	// streamed on the ADS channel.
	AdsConfig            *core.ApiConfigSource `protobuf:"bytes,3,opt,name=ads_config,json=adsConfig,proto3" json:"ads_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *Bootstrap_DynamicResources) Reset()         { *m = Bootstrap_DynamicResources{} }
func (m *Bootstrap_DynamicResources) String() string { return proto.CompactTextString(m) }
func (*Bootstrap_DynamicResources) ProtoMessage()    {}
func (*Bootstrap_DynamicResources) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{0, 1}
}
func (m *Bootstrap_DynamicResources) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Bootstrap_DynamicResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Bootstrap_DynamicResources.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 *Bootstrap_DynamicResources) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bootstrap_DynamicResources.Merge(m, src)
}
func (m *Bootstrap_DynamicResources) XXX_Size() int {
	return m.Size()
}
func (m *Bootstrap_DynamicResources) XXX_DiscardUnknown() {
	xxx_messageInfo_Bootstrap_DynamicResources.DiscardUnknown(m)
}

var xxx_messageInfo_Bootstrap_DynamicResources proto.InternalMessageInfo

func (m *Bootstrap_DynamicResources) GetLdsConfig() *core.ConfigSource {
	if m != nil {
		return m.LdsConfig
	}
	return nil
}

func (m *Bootstrap_DynamicResources) GetCdsConfig() *core.ConfigSource {
	if m != nil {
		return m.CdsConfig
	}
	return nil
}

func (m *Bootstrap_DynamicResources) GetAdsConfig() *core.ApiConfigSource {
	if m != nil {
		return m.AdsConfig
	}
	return nil
}

// Administration interface :ref:`operations documentation
// <operations_admin_interface>`.
type Admin struct {
	// The path to write the access log for the administration server. If no
	// access log is desired specify ‘/dev/null’. This is only required if
	// :ref:`address <envoy_api_field_config.bootstrap.v2.Admin.address>` is set.
	AccessLogPath string `protobuf:"bytes,1,opt,name=access_log_path,json=accessLogPath,proto3" json:"access_log_path,omitempty"`
	// The cpu profiler output path for the administration server. If no profile
	// path is specified, the default is ‘/var/log/envoy/envoy.prof’.
	ProfilePath string `protobuf:"bytes,2,opt,name=profile_path,json=profilePath,proto3" json:"profile_path,omitempty"`
	// The TCP address that the administration server will listen on.
	// If not specified, Envoy will not start an administration server.
	Address *core.Address `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
	// Additional socket options that may not be present in Envoy source code or
	// precompiled binaries.
	SocketOptions        []*core.SocketOption `protobuf:"bytes,4,rep,name=socket_options,json=socketOptions,proto3" json:"socket_options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Admin) Reset()         { *m = Admin{} }
func (m *Admin) String() string { return proto.CompactTextString(m) }
func (*Admin) ProtoMessage()    {}
func (*Admin) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{1}
}
func (m *Admin) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Admin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Admin.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 *Admin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Admin.Merge(m, src)
}
func (m *Admin) XXX_Size() int {
	return m.Size()
}
func (m *Admin) XXX_DiscardUnknown() {
	xxx_messageInfo_Admin.DiscardUnknown(m)
}

var xxx_messageInfo_Admin proto.InternalMessageInfo

func (m *Admin) GetAccessLogPath() string {
	if m != nil {
		return m.AccessLogPath
	}
	return ""
}

func (m *Admin) GetProfilePath() string {
	if m != nil {
		return m.ProfilePath
	}
	return ""
}

func (m *Admin) GetAddress() *core.Address {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *Admin) GetSocketOptions() []*core.SocketOption {
	if m != nil {
		return m.SocketOptions
	}
	return nil
}

// Cluster manager :ref:`architecture overview <arch_overview_cluster_manager>`.
type ClusterManager struct {
	// Name of the local cluster (i.e., the cluster that owns the Envoy running
	// this configuration). In order to enable :ref:`zone aware routing
	// <arch_overview_load_balancing_zone_aware_routing>` this option must be set.
	// If *local_cluster_name* is defined then :ref:`clusters
	// <envoy_api_msg_Cluster>` must be defined in the :ref:`Bootstrap
	// static cluster resources
	// <envoy_api_field_config.bootstrap.v2.Bootstrap.StaticResources.clusters>`. This is unrelated to
	// the :option:`--service-cluster` option which does not `affect zone aware
	// routing <https://github.com/envoyproxy/envoy/issues/774>`_.
	LocalClusterName string `protobuf:"bytes,1,opt,name=local_cluster_name,json=localClusterName,proto3" json:"local_cluster_name,omitempty"`
	// Optional global configuration for outlier detection.
	OutlierDetection *ClusterManager_OutlierDetection `protobuf:"bytes,2,opt,name=outlier_detection,json=outlierDetection,proto3" json:"outlier_detection,omitempty"`
	// Optional configuration used to bind newly established upstream connections.
	// This may be overridden on a per-cluster basis by upstream_bind_config in the cds_config.
	UpstreamBindConfig *core.BindConfig `protobuf:"bytes,3,opt,name=upstream_bind_config,json=upstreamBindConfig,proto3" json:"upstream_bind_config,omitempty"`
	// A management server endpoint to stream load stats to via
	// *StreamLoadStats*. This must have :ref:`api_type
	// <envoy_api_field_core.ApiConfigSource.api_type>` :ref:`GRPC
	// <envoy_api_enum_value_core.ApiConfigSource.ApiType.GRPC>`.
	LoadStatsConfig      *core.ApiConfigSource `protobuf:"bytes,4,opt,name=load_stats_config,json=loadStatsConfig,proto3" json:"load_stats_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ClusterManager) Reset()         { *m = ClusterManager{} }
func (m *ClusterManager) String() string { return proto.CompactTextString(m) }
func (*ClusterManager) ProtoMessage()    {}
func (*ClusterManager) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{2}
}
func (m *ClusterManager) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterManager) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClusterManager.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 *ClusterManager) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterManager.Merge(m, src)
}
func (m *ClusterManager) XXX_Size() int {
	return m.Size()
}
func (m *ClusterManager) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterManager.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterManager proto.InternalMessageInfo

func (m *ClusterManager) GetLocalClusterName() string {
	if m != nil {
		return m.LocalClusterName
	}
	return ""
}

func (m *ClusterManager) GetOutlierDetection() *ClusterManager_OutlierDetection {
	if m != nil {
		return m.OutlierDetection
	}
	return nil
}

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

func (m *ClusterManager) GetLoadStatsConfig() *core.ApiConfigSource {
	if m != nil {
		return m.LoadStatsConfig
	}
	return nil
}

type ClusterManager_OutlierDetection struct {
	// Specifies the path to the outlier event log.
	EventLogPath         string   `protobuf:"bytes,1,opt,name=event_log_path,json=eventLogPath,proto3" json:"event_log_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClusterManager_OutlierDetection) Reset()         { *m = ClusterManager_OutlierDetection{} }
func (m *ClusterManager_OutlierDetection) String() string { return proto.CompactTextString(m) }
func (*ClusterManager_OutlierDetection) ProtoMessage()    {}
func (*ClusterManager_OutlierDetection) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{2, 0}
}
func (m *ClusterManager_OutlierDetection) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterManager_OutlierDetection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClusterManager_OutlierDetection.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 *ClusterManager_OutlierDetection) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterManager_OutlierDetection.Merge(m, src)
}
func (m *ClusterManager_OutlierDetection) XXX_Size() int {
	return m.Size()
}
func (m *ClusterManager_OutlierDetection) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterManager_OutlierDetection.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterManager_OutlierDetection proto.InternalMessageInfo

func (m *ClusterManager_OutlierDetection) GetEventLogPath() string {
	if m != nil {
		return m.EventLogPath
	}
	return ""
}

// Envoy process watchdog configuration. When configured, this monitors for
// nonresponsive threads and kills the process after the configured thresholds.
// See the :ref:`watchdog documentation <operations_performance_watchdog>` for more information.
type Watchdog struct {
	// The duration after which Envoy counts a nonresponsive thread in the
	// *watchdog_miss* statistic. If not specified the default is 200ms.
	MissTimeout *types.Duration `protobuf:"bytes,1,opt,name=miss_timeout,json=missTimeout,proto3" json:"miss_timeout,omitempty"`
	// The duration after which Envoy counts a nonresponsive thread in the
	// *watchdog_mega_miss* statistic. If not specified the default is
	// 1000ms.
	MegamissTimeout *types.Duration `protobuf:"bytes,2,opt,name=megamiss_timeout,json=megamissTimeout,proto3" json:"megamiss_timeout,omitempty"`
	// If a watched thread has been nonresponsive for this duration, assume a
	// programming error and kill the entire Envoy process. Set to 0 to disable
	// kill behavior. If not specified the default is 0 (disabled).
	KillTimeout *types.Duration `protobuf:"bytes,3,opt,name=kill_timeout,json=killTimeout,proto3" json:"kill_timeout,omitempty"`
	// If at least two watched threads have been nonresponsive for at least this
	// duration assume a true deadlock and kill the entire Envoy process. Set to 0
	// to disable this behavior. If not specified the default is 0 (disabled).
	MultikillTimeout     *types.Duration `protobuf:"bytes,4,opt,name=multikill_timeout,json=multikillTimeout,proto3" json:"multikill_timeout,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Watchdog) Reset()         { *m = Watchdog{} }
func (m *Watchdog) String() string { return proto.CompactTextString(m) }
func (*Watchdog) ProtoMessage()    {}
func (*Watchdog) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{3}
}
func (m *Watchdog) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Watchdog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Watchdog.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 *Watchdog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Watchdog.Merge(m, src)
}
func (m *Watchdog) XXX_Size() int {
	return m.Size()
}
func (m *Watchdog) XXX_DiscardUnknown() {
	xxx_messageInfo_Watchdog.DiscardUnknown(m)
}

var xxx_messageInfo_Watchdog proto.InternalMessageInfo

func (m *Watchdog) GetMissTimeout() *types.Duration {
	if m != nil {
		return m.MissTimeout
	}
	return nil
}

func (m *Watchdog) GetMegamissTimeout() *types.Duration {
	if m != nil {
		return m.MegamissTimeout
	}
	return nil
}

func (m *Watchdog) GetKillTimeout() *types.Duration {
	if m != nil {
		return m.KillTimeout
	}
	return nil
}

func (m *Watchdog) GetMultikillTimeout() *types.Duration {
	if m != nil {
		return m.MultikillTimeout
	}
	return nil
}

// Runtime :ref:`configuration overview <config_runtime>` (deprecated).
type Runtime struct {
	// The implementation assumes that the file system tree is accessed via a
	// symbolic link. An atomic link swap is used when a new tree should be
	// switched to. This parameter specifies the path to the symbolic link. Envoy
	// will watch the location for changes and reload the file system tree when
	// they happen. If this parameter is not set, there will be no disk based
	// runtime.
	SymlinkRoot string `protobuf:"bytes,1,opt,name=symlink_root,json=symlinkRoot,proto3" json:"symlink_root,omitempty"`
	// Specifies the subdirectory to load within the root directory. This is
	// useful if multiple systems share the same delivery mechanism. Envoy
	// configuration elements can be contained in a dedicated subdirectory.
	Subdirectory string `protobuf:"bytes,2,opt,name=subdirectory,proto3" json:"subdirectory,omitempty"`
	// Specifies an optional subdirectory to load within the root directory. If
	// specified and the directory exists, configuration values within this
	// directory will override those found in the primary subdirectory. This is
	// useful when Envoy is deployed across many different types of servers.
	// Sometimes it is useful to have a per service cluster directory for runtime
	// configuration. See below for exactly how the override directory is used.
	OverrideSubdirectory string `protobuf:"bytes,3,opt,name=override_subdirectory,json=overrideSubdirectory,proto3" json:"override_subdirectory,omitempty"`
	// Static base runtime. This will be :ref:`overridden
	// <config_runtime_layering>` by other runtime layers, e.g.
	// disk or admin. This follows the :ref:`runtime protobuf JSON representation
	// encoding <config_runtime_proto_json>`.
	Base                 *types.Struct `protobuf:"bytes,4,opt,name=base,proto3" json:"base,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Runtime) Reset()         { *m = Runtime{} }
func (m *Runtime) String() string { return proto.CompactTextString(m) }
func (*Runtime) ProtoMessage()    {}
func (*Runtime) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{4}
}
func (m *Runtime) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Runtime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Runtime.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 *Runtime) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Runtime.Merge(m, src)
}
func (m *Runtime) XXX_Size() int {
	return m.Size()
}
func (m *Runtime) XXX_DiscardUnknown() {
	xxx_messageInfo_Runtime.DiscardUnknown(m)
}

var xxx_messageInfo_Runtime proto.InternalMessageInfo

func (m *Runtime) GetSymlinkRoot() string {
	if m != nil {
		return m.SymlinkRoot
	}
	return ""
}

func (m *Runtime) GetSubdirectory() string {
	if m != nil {
		return m.Subdirectory
	}
	return ""
}

func (m *Runtime) GetOverrideSubdirectory() string {
	if m != nil {
		return m.OverrideSubdirectory
	}
	return ""
}

func (m *Runtime) GetBase() *types.Struct {
	if m != nil {
		return m.Base
	}
	return nil
}

// [#next-free-field: 6]
type RuntimeLayer struct {
	// Descriptive name for the runtime layer. This is only used for the runtime
	// :http:get:`/runtime` output.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to LayerSpecifier:
	//	*RuntimeLayer_StaticLayer
	//	*RuntimeLayer_DiskLayer_
	//	*RuntimeLayer_AdminLayer_
	//	*RuntimeLayer_RtdsLayer_
	LayerSpecifier       isRuntimeLayer_LayerSpecifier `protobuf_oneof:"layer_specifier"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *RuntimeLayer) Reset()         { *m = RuntimeLayer{} }
func (m *RuntimeLayer) String() string { return proto.CompactTextString(m) }
func (*RuntimeLayer) ProtoMessage()    {}
func (*RuntimeLayer) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{5}
}
func (m *RuntimeLayer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RuntimeLayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RuntimeLayer.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 *RuntimeLayer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeLayer.Merge(m, src)
}
func (m *RuntimeLayer) XXX_Size() int {
	return m.Size()
}
func (m *RuntimeLayer) XXX_DiscardUnknown() {
	xxx_messageInfo_RuntimeLayer.DiscardUnknown(m)
}

var xxx_messageInfo_RuntimeLayer proto.InternalMessageInfo

type isRuntimeLayer_LayerSpecifier interface {
	isRuntimeLayer_LayerSpecifier()
	MarshalTo([]byte) (int, error)
	Size() int
}

type RuntimeLayer_StaticLayer struct {
	StaticLayer *types.Struct `protobuf:"bytes,2,opt,name=static_layer,json=staticLayer,proto3,oneof"`
}
type RuntimeLayer_DiskLayer_ struct {
	DiskLayer *RuntimeLayer_DiskLayer `protobuf:"bytes,3,opt,name=disk_layer,json=diskLayer,proto3,oneof"`
}
type RuntimeLayer_AdminLayer_ struct {
	AdminLayer *RuntimeLayer_AdminLayer `protobuf:"bytes,4,opt,name=admin_layer,json=adminLayer,proto3,oneof"`
}
type RuntimeLayer_RtdsLayer_ struct {
	RtdsLayer *RuntimeLayer_RtdsLayer `protobuf:"bytes,5,opt,name=rtds_layer,json=rtdsLayer,proto3,oneof"`
}

func (*RuntimeLayer_StaticLayer) isRuntimeLayer_LayerSpecifier() {}
func (*RuntimeLayer_DiskLayer_) isRuntimeLayer_LayerSpecifier()  {}
func (*RuntimeLayer_AdminLayer_) isRuntimeLayer_LayerSpecifier() {}
func (*RuntimeLayer_RtdsLayer_) isRuntimeLayer_LayerSpecifier()  {}

func (m *RuntimeLayer) GetLayerSpecifier() isRuntimeLayer_LayerSpecifier {
	if m != nil {
		return m.LayerSpecifier
	}
	return nil
}

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

func (m *RuntimeLayer) GetStaticLayer() *types.Struct {
	if x, ok := m.GetLayerSpecifier().(*RuntimeLayer_StaticLayer); ok {
		return x.StaticLayer
	}
	return nil
}

func (m *RuntimeLayer) GetDiskLayer() *RuntimeLayer_DiskLayer {
	if x, ok := m.GetLayerSpecifier().(*RuntimeLayer_DiskLayer_); ok {
		return x.DiskLayer
	}
	return nil
}

func (m *RuntimeLayer) GetAdminLayer() *RuntimeLayer_AdminLayer {
	if x, ok := m.GetLayerSpecifier().(*RuntimeLayer_AdminLayer_); ok {
		return x.AdminLayer
	}
	return nil
}

func (m *RuntimeLayer) GetRtdsLayer() *RuntimeLayer_RtdsLayer {
	if x, ok := m.GetLayerSpecifier().(*RuntimeLayer_RtdsLayer_); ok {
		return x.RtdsLayer
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RuntimeLayer) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RuntimeLayer_StaticLayer)(nil),
		(*RuntimeLayer_DiskLayer_)(nil),
		(*RuntimeLayer_AdminLayer_)(nil),
		(*RuntimeLayer_RtdsLayer_)(nil),
	}
}

// :ref:`Disk runtime <config_runtime_local_disk>` layer.
type RuntimeLayer_DiskLayer struct {
	// The implementation assumes that the file system tree is accessed via a
	// symbolic link. An atomic link swap is used when a new tree should be
	// switched to. This parameter specifies the path to the symbolic link.
	// Envoy will watch the location for changes and reload the file system tree
	// when they happen. See documentation on runtime :ref:`atomicity
	// <config_runtime_atomicity>` for further details on how reloads are
	// treated.
	SymlinkRoot string `protobuf:"bytes,1,opt,name=symlink_root,json=symlinkRoot,proto3" json:"symlink_root,omitempty"`
	// Specifies the subdirectory to load within the root directory. This is
	// useful if multiple systems share the same delivery mechanism. Envoy
	// configuration elements can be contained in a dedicated subdirectory.
	Subdirectory string `protobuf:"bytes,3,opt,name=subdirectory,proto3" json:"subdirectory,omitempty"`
	// :ref:`Append <config_runtime_local_disk_service_cluster_subdirs>` the
	// service cluster to the path under symlink root.
	AppendServiceCluster bool     `protobuf:"varint,2,opt,name=append_service_cluster,json=appendServiceCluster,proto3" json:"append_service_cluster,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RuntimeLayer_DiskLayer) Reset()         { *m = RuntimeLayer_DiskLayer{} }
func (m *RuntimeLayer_DiskLayer) String() string { return proto.CompactTextString(m) }
func (*RuntimeLayer_DiskLayer) ProtoMessage()    {}
func (*RuntimeLayer_DiskLayer) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{5, 0}
}
func (m *RuntimeLayer_DiskLayer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RuntimeLayer_DiskLayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RuntimeLayer_DiskLayer.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 *RuntimeLayer_DiskLayer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeLayer_DiskLayer.Merge(m, src)
}
func (m *RuntimeLayer_DiskLayer) XXX_Size() int {
	return m.Size()
}
func (m *RuntimeLayer_DiskLayer) XXX_DiscardUnknown() {
	xxx_messageInfo_RuntimeLayer_DiskLayer.DiscardUnknown(m)
}

var xxx_messageInfo_RuntimeLayer_DiskLayer proto.InternalMessageInfo

func (m *RuntimeLayer_DiskLayer) GetSymlinkRoot() string {
	if m != nil {
		return m.SymlinkRoot
	}
	return ""
}

func (m *RuntimeLayer_DiskLayer) GetSubdirectory() string {
	if m != nil {
		return m.Subdirectory
	}
	return ""
}

func (m *RuntimeLayer_DiskLayer) GetAppendServiceCluster() bool {
	if m != nil {
		return m.AppendServiceCluster
	}
	return false
}

// :ref:`Admin console runtime <config_runtime_admin>` layer.
type RuntimeLayer_AdminLayer struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RuntimeLayer_AdminLayer) Reset()         { *m = RuntimeLayer_AdminLayer{} }
func (m *RuntimeLayer_AdminLayer) String() string { return proto.CompactTextString(m) }
func (*RuntimeLayer_AdminLayer) ProtoMessage()    {}
func (*RuntimeLayer_AdminLayer) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{5, 1}
}
func (m *RuntimeLayer_AdminLayer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RuntimeLayer_AdminLayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RuntimeLayer_AdminLayer.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 *RuntimeLayer_AdminLayer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeLayer_AdminLayer.Merge(m, src)
}
func (m *RuntimeLayer_AdminLayer) XXX_Size() int {
	return m.Size()
}
func (m *RuntimeLayer_AdminLayer) XXX_DiscardUnknown() {
	xxx_messageInfo_RuntimeLayer_AdminLayer.DiscardUnknown(m)
}

var xxx_messageInfo_RuntimeLayer_AdminLayer proto.InternalMessageInfo

// :ref:`Runtime Discovery Service (RTDS) <config_runtime_rtds>` layer.
type RuntimeLayer_RtdsLayer struct {
	// Resource to subscribe to at *rtds_config* for the RTDS layer.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// RTDS configuration source.
	RtdsConfig           *core.ConfigSource `protobuf:"bytes,2,opt,name=rtds_config,json=rtdsConfig,proto3" json:"rtds_config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *RuntimeLayer_RtdsLayer) Reset()         { *m = RuntimeLayer_RtdsLayer{} }
func (m *RuntimeLayer_RtdsLayer) String() string { return proto.CompactTextString(m) }
func (*RuntimeLayer_RtdsLayer) ProtoMessage()    {}
func (*RuntimeLayer_RtdsLayer) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{5, 2}
}
func (m *RuntimeLayer_RtdsLayer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RuntimeLayer_RtdsLayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RuntimeLayer_RtdsLayer.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 *RuntimeLayer_RtdsLayer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeLayer_RtdsLayer.Merge(m, src)
}
func (m *RuntimeLayer_RtdsLayer) XXX_Size() int {
	return m.Size()
}
func (m *RuntimeLayer_RtdsLayer) XXX_DiscardUnknown() {
	xxx_messageInfo_RuntimeLayer_RtdsLayer.DiscardUnknown(m)
}

var xxx_messageInfo_RuntimeLayer_RtdsLayer proto.InternalMessageInfo

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

func (m *RuntimeLayer_RtdsLayer) GetRtdsConfig() *core.ConfigSource {
	if m != nil {
		return m.RtdsConfig
	}
	return nil
}

// Runtime :ref:`configuration overview <config_runtime>`.
type LayeredRuntime struct {
	// The :ref:`layers <config_runtime_layering>` of the runtime. This is ordered
	// such that later layers in the list overlay earlier entries.
	Layers               []*RuntimeLayer `protobuf:"bytes,1,rep,name=layers,proto3" json:"layers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *LayeredRuntime) Reset()         { *m = LayeredRuntime{} }
func (m *LayeredRuntime) String() string { return proto.CompactTextString(m) }
func (*LayeredRuntime) ProtoMessage()    {}
func (*LayeredRuntime) Descriptor() ([]byte, []int) {
	return fileDescriptor_f1197defdf9c5e6a, []int{6}
}
func (m *LayeredRuntime) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LayeredRuntime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LayeredRuntime.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 *LayeredRuntime) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LayeredRuntime.Merge(m, src)
}
func (m *LayeredRuntime) XXX_Size() int {
	return m.Size()
}
func (m *LayeredRuntime) XXX_DiscardUnknown() {
	xxx_messageInfo_LayeredRuntime.DiscardUnknown(m)
}

var xxx_messageInfo_LayeredRuntime proto.InternalMessageInfo

func (m *LayeredRuntime) GetLayers() []*RuntimeLayer {
	if m != nil {
		return m.Layers
	}
	return nil
}

func init() {
	proto.RegisterType((*Bootstrap)(nil), "envoy.config.bootstrap.v2.Bootstrap")
	proto.RegisterType((*Bootstrap_StaticResources)(nil), "envoy.config.bootstrap.v2.Bootstrap.StaticResources")
	proto.RegisterType((*Bootstrap_DynamicResources)(nil), "envoy.config.bootstrap.v2.Bootstrap.DynamicResources")
	proto.RegisterType((*Admin)(nil), "envoy.config.bootstrap.v2.Admin")
	proto.RegisterType((*ClusterManager)(nil), "envoy.config.bootstrap.v2.ClusterManager")
	proto.RegisterType((*ClusterManager_OutlierDetection)(nil), "envoy.config.bootstrap.v2.ClusterManager.OutlierDetection")
	proto.RegisterType((*Watchdog)(nil), "envoy.config.bootstrap.v2.Watchdog")
	proto.RegisterType((*Runtime)(nil), "envoy.config.bootstrap.v2.Runtime")
	proto.RegisterType((*RuntimeLayer)(nil), "envoy.config.bootstrap.v2.RuntimeLayer")
	proto.RegisterType((*RuntimeLayer_DiskLayer)(nil), "envoy.config.bootstrap.v2.RuntimeLayer.DiskLayer")
	proto.RegisterType((*RuntimeLayer_AdminLayer)(nil), "envoy.config.bootstrap.v2.RuntimeLayer.AdminLayer")
	proto.RegisterType((*RuntimeLayer_RtdsLayer)(nil), "envoy.config.bootstrap.v2.RuntimeLayer.RtdsLayer")
	proto.RegisterType((*LayeredRuntime)(nil), "envoy.config.bootstrap.v2.LayeredRuntime")
}

func init() {
	proto.RegisterFile("envoy/config/bootstrap/v2/bootstrap.proto", fileDescriptor_f1197defdf9c5e6a)
}

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

func (m *Bootstrap) 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 *Bootstrap) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Bootstrap) 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.StatsServerVersionOverride != nil {
		{
			size, err := m.StatsServerVersionOverride.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if len(m.HeaderPrefix) > 0 {
		i -= len(m.HeaderPrefix)
		copy(dAtA[i:], m.HeaderPrefix)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.HeaderPrefix)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if m.LayeredRuntime != nil {
		{
			size, err := m.LayeredRuntime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.EnableDispatcherStats {
		i--
		if m.EnableDispatcherStats {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.OverloadManager != nil {
		{
			size, err := m.OverloadManager.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.HdsConfig != nil {
		{
			size, err := m.HdsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.StatsConfig != nil {
		{
			size, err := m.StatsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.Admin != nil {
		{
			size, err := m.Admin.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.Runtime != nil {
		{
			size, err := m.Runtime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.Tracing != nil {
		{
			size, err := m.Tracing.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Watchdog != nil {
		{
			size, err := m.Watchdog.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.StatsFlushInterval != nil {
		{
			size, err := m.StatsFlushInterval.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.StatsSinks) > 0 {
		for iNdEx := len(m.StatsSinks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StatsSinks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBootstrap(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.FlagsPath) > 0 {
		i -= len(m.FlagsPath)
		copy(dAtA[i:], m.FlagsPath)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.FlagsPath)))
		i--
		dAtA[i] = 0x2a
	}
	if m.ClusterManager != nil {
		{
			size, err := m.ClusterManager.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.DynamicResources != nil {
		{
			size, err := m.DynamicResources.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.StaticResources != nil {
		{
			size, err := m.StaticResources.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Node != nil {
		{
			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Bootstrap_StaticResources) 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 *Bootstrap_StaticResources) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Bootstrap_StaticResources) 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.Secrets) > 0 {
		for iNdEx := len(m.Secrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Secrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBootstrap(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Clusters) > 0 {
		for iNdEx := len(m.Clusters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Clusters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBootstrap(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Listeners) > 0 {
		for iNdEx := len(m.Listeners) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Listeners[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBootstrap(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Bootstrap_DynamicResources) 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 *Bootstrap_DynamicResources) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Bootstrap_DynamicResources) 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.AdsConfig != nil {
		{
			size, err := m.AdsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.CdsConfig != nil {
		{
			size, err := m.CdsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.LdsConfig != nil {
		{
			size, err := m.LdsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Admin) 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 *Admin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Admin) 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.SocketOptions) > 0 {
		for iNdEx := len(m.SocketOptions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SocketOptions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBootstrap(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Address != nil {
		{
			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ProfilePath) > 0 {
		i -= len(m.ProfilePath)
		copy(dAtA[i:], m.ProfilePath)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.ProfilePath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccessLogPath) > 0 {
		i -= len(m.AccessLogPath)
		copy(dAtA[i:], m.AccessLogPath)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.AccessLogPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ClusterManager) 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 *ClusterManager) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClusterManager) 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.LoadStatsConfig != nil {
		{
			size, err := m.LoadStatsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UpstreamBindConfig != nil {
		{
			size, err := m.UpstreamBindConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.OutlierDetection != nil {
		{
			size, err := m.OutlierDetection.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.LocalClusterName) > 0 {
		i -= len(m.LocalClusterName)
		copy(dAtA[i:], m.LocalClusterName)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.LocalClusterName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ClusterManager_OutlierDetection) 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 *ClusterManager_OutlierDetection) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClusterManager_OutlierDetection) 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.EventLogPath) > 0 {
		i -= len(m.EventLogPath)
		copy(dAtA[i:], m.EventLogPath)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.EventLogPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Watchdog) 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 *Watchdog) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Watchdog) 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.MultikillTimeout != nil {
		{
			size, err := m.MultikillTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.KillTimeout != nil {
		{
			size, err := m.KillTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.MegamissTimeout != nil {
		{
			size, err := m.MegamissTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MissTimeout != nil {
		{
			size, err := m.MissTimeout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Runtime) 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 *Runtime) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Runtime) 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.Base != nil {
		{
			size, err := m.Base.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.OverrideSubdirectory) > 0 {
		i -= len(m.OverrideSubdirectory)
		copy(dAtA[i:], m.OverrideSubdirectory)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.OverrideSubdirectory)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Subdirectory) > 0 {
		i -= len(m.Subdirectory)
		copy(dAtA[i:], m.Subdirectory)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.Subdirectory)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SymlinkRoot) > 0 {
		i -= len(m.SymlinkRoot)
		copy(dAtA[i:], m.SymlinkRoot)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.SymlinkRoot)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RuntimeLayer) 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 *RuntimeLayer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RuntimeLayer) 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.LayerSpecifier != nil {
		{
			size := m.LayerSpecifier.Size()
			i -= size
			if _, err := m.LayerSpecifier.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RuntimeLayer_StaticLayer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StaticLayer != nil {
		{
			size, err := m.StaticLayer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *RuntimeLayer_DiskLayer_) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *RuntimeLayer_DiskLayer_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DiskLayer != nil {
		{
			size, err := m.DiskLayer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *RuntimeLayer_AdminLayer_) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *RuntimeLayer_AdminLayer_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AdminLayer != nil {
		{
			size, err := m.AdminLayer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *RuntimeLayer_RtdsLayer_) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *RuntimeLayer_RtdsLayer_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RtdsLayer != nil {
		{
			size, err := m.RtdsLayer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *RuntimeLayer_DiskLayer) 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 *RuntimeLayer_DiskLayer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RuntimeLayer_DiskLayer) 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.Subdirectory) > 0 {
		i -= len(m.Subdirectory)
		copy(dAtA[i:], m.Subdirectory)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.Subdirectory)))
		i--
		dAtA[i] = 0x1a
	}
	if m.AppendServiceCluster {
		i--
		if m.AppendServiceCluster {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.SymlinkRoot) > 0 {
		i -= len(m.SymlinkRoot)
		copy(dAtA[i:], m.SymlinkRoot)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.SymlinkRoot)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RuntimeLayer_AdminLayer) 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 *RuntimeLayer_AdminLayer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RuntimeLayer_AdminLayer) 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)
	}
	return len(dAtA) - i, nil
}

func (m *RuntimeLayer_RtdsLayer) 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 *RuntimeLayer_RtdsLayer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RuntimeLayer_RtdsLayer) 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.RtdsConfig != nil {
		{
			size, err := m.RtdsConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintBootstrap(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintBootstrap(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LayeredRuntime) 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 *LayeredRuntime) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LayeredRuntime) 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.Layers) > 0 {
		for iNdEx := len(m.Layers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Layers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBootstrap(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintBootstrap(dAtA []byte, offset int, v uint64) int {
	offset -= sovBootstrap(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Bootstrap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.StaticResources != nil {
		l = m.StaticResources.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.DynamicResources != nil {
		l = m.DynamicResources.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.ClusterManager != nil {
		l = m.ClusterManager.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	l = len(m.FlagsPath)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if len(m.StatsSinks) > 0 {
		for _, e := range m.StatsSinks {
			l = e.Size()
			n += 1 + l + sovBootstrap(uint64(l))
		}
	}
	if m.StatsFlushInterval != nil {
		l = m.StatsFlushInterval.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.Watchdog != nil {
		l = m.Watchdog.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.Tracing != nil {
		l = m.Tracing.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.Runtime != nil {
		l = m.Runtime.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.Admin != nil {
		l = m.Admin.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.StatsConfig != nil {
		l = m.StatsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.HdsConfig != nil {
		l = m.HdsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.OverloadManager != nil {
		l = m.OverloadManager.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.EnableDispatcherStats {
		n += 3
	}
	if m.LayeredRuntime != nil {
		l = m.LayeredRuntime.Size()
		n += 2 + l + sovBootstrap(uint64(l))
	}
	l = len(m.HeaderPrefix)
	if l > 0 {
		n += 2 + l + sovBootstrap(uint64(l))
	}
	if m.StatsServerVersionOverride != nil {
		l = m.StatsServerVersionOverride.Size()
		n += 2 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Bootstrap_StaticResources) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Listeners) > 0 {
		for _, e := range m.Listeners {
			l = e.Size()
			n += 1 + l + sovBootstrap(uint64(l))
		}
	}
	if len(m.Clusters) > 0 {
		for _, e := range m.Clusters {
			l = e.Size()
			n += 1 + l + sovBootstrap(uint64(l))
		}
	}
	if len(m.Secrets) > 0 {
		for _, e := range m.Secrets {
			l = e.Size()
			n += 1 + l + sovBootstrap(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Bootstrap_DynamicResources) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LdsConfig != nil {
		l = m.LdsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.CdsConfig != nil {
		l = m.CdsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.AdsConfig != nil {
		l = m.AdsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Admin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccessLogPath)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	l = len(m.ProfilePath)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.Address != nil {
		l = m.Address.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if len(m.SocketOptions) > 0 {
		for _, e := range m.SocketOptions {
			l = e.Size()
			n += 1 + l + sovBootstrap(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClusterManager) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LocalClusterName)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.OutlierDetection != nil {
		l = m.OutlierDetection.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.UpstreamBindConfig != nil {
		l = m.UpstreamBindConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.LoadStatsConfig != nil {
		l = m.LoadStatsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClusterManager_OutlierDetection) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.EventLogPath)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Watchdog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MissTimeout != nil {
		l = m.MissTimeout.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.MegamissTimeout != nil {
		l = m.MegamissTimeout.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.KillTimeout != nil {
		l = m.KillTimeout.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.MultikillTimeout != nil {
		l = m.MultikillTimeout.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Runtime) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SymlinkRoot)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	l = len(m.Subdirectory)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	l = len(m.OverrideSubdirectory)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.Base != nil {
		l = m.Base.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RuntimeLayer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.LayerSpecifier != nil {
		n += m.LayerSpecifier.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RuntimeLayer_StaticLayer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StaticLayer != nil {
		l = m.StaticLayer.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	return n
}
func (m *RuntimeLayer_DiskLayer_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DiskLayer != nil {
		l = m.DiskLayer.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	return n
}
func (m *RuntimeLayer_AdminLayer_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AdminLayer != nil {
		l = m.AdminLayer.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	return n
}
func (m *RuntimeLayer_RtdsLayer_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RtdsLayer != nil {
		l = m.RtdsLayer.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	return n
}
func (m *RuntimeLayer_DiskLayer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SymlinkRoot)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.AppendServiceCluster {
		n += 2
	}
	l = len(m.Subdirectory)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *RuntimeLayer_RtdsLayer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.RtdsConfig != nil {
		l = m.RtdsConfig.Size()
		n += 1 + l + sovBootstrap(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LayeredRuntime) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Layers) > 0 {
		for _, e := range m.Layers {
			l = e.Size()
			n += 1 + l + sovBootstrap(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovBootstrap(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBootstrap(x uint64) (n int) {
	return sovBootstrap(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Bootstrap) 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 ErrIntOverflowBootstrap
			}
			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: Bootstrap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bootstrap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Node == nil {
				m.Node = &core.Node{}
			}
			if err := m.Node.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StaticResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StaticResources == nil {
				m.StaticResources = &Bootstrap_StaticResources{}
			}
			if err := m.StaticResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DynamicResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DynamicResources == nil {
				m.DynamicResources = &Bootstrap_DynamicResources{}
			}
			if err := m.DynamicResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterManager", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClusterManager == nil {
				m.ClusterManager = &ClusterManager{}
			}
			if err := m.ClusterManager.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlagsPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FlagsPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatsSinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StatsSinks = append(m.StatsSinks, &v2.StatsSink{})
			if err := m.StatsSinks[len(m.StatsSinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatsFlushInterval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StatsFlushInterval == nil {
				m.StatsFlushInterval = &types.Duration{}
			}
			if err := m.StatsFlushInterval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Watchdog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Watchdog == nil {
				m.Watchdog = &Watchdog{}
			}
			if err := m.Watchdog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tracing", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tracing == nil {
				m.Tracing = &v21.Tracing{}
			}
			if err := m.Tracing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Runtime == nil {
				m.Runtime = &Runtime{}
			}
			if err := m.Runtime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Admin == nil {
				m.Admin = &Admin{}
			}
			if err := m.Admin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StatsConfig == nil {
				m.StatsConfig = &v2.StatsConfig{}
			}
			if err := m.StatsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HdsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.HdsConfig == nil {
				m.HdsConfig = &core.ApiConfigSource{}
			}
			if err := m.HdsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OverloadManager", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OverloadManager == nil {
				m.OverloadManager = &v2alpha.OverloadManager{}
			}
			if err := m.OverloadManager.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableDispatcherStats", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableDispatcherStats = bool(v != 0)
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LayeredRuntime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LayeredRuntime == nil {
				m.LayeredRuntime = &LayeredRuntime{}
			}
			if err := m.LayeredRuntime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderPrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderPrefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatsServerVersionOverride", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StatsServerVersionOverride == nil {
				m.StatsServerVersionOverride = &types.UInt64Value{}
			}
			if err := m.StatsServerVersionOverride.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *Bootstrap_StaticResources) 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 ErrIntOverflowBootstrap
			}
			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: StaticResources: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StaticResources: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Listeners", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Listeners = append(m.Listeners, &v22.Listener{})
			if err := m.Listeners[len(m.Listeners)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Clusters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Clusters = append(m.Clusters, &v22.Cluster{})
			if err := m.Clusters[len(m.Clusters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Secrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Secrets = append(m.Secrets, &auth.Secret{})
			if err := m.Secrets[len(m.Secrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *Bootstrap_DynamicResources) 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 ErrIntOverflowBootstrap
			}
			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: DynamicResources: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DynamicResources: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LdsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LdsConfig == nil {
				m.LdsConfig = &core.ConfigSource{}
			}
			if err := m.LdsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CdsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CdsConfig == nil {
				m.CdsConfig = &core.ConfigSource{}
			}
			if err := m.CdsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AdsConfig == nil {
				m.AdsConfig = &core.ApiConfigSource{}
			}
			if err := m.AdsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *Admin) 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 ErrIntOverflowBootstrap
			}
			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: Admin: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Admin: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessLogPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfilePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfilePath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Address == nil {
				m.Address = &core.Address{}
			}
			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SocketOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SocketOptions = append(m.SocketOptions, &core.SocketOption{})
			if err := m.SocketOptions[len(m.SocketOptions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *ClusterManager) 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 ErrIntOverflowBootstrap
			}
			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: ClusterManager: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterManager: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalClusterName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalClusterName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutlierDetection", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OutlierDetection == nil {
				m.OutlierDetection = &ClusterManager_OutlierDetection{}
			}
			if err := m.OutlierDetection.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpstreamBindConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpstreamBindConfig == nil {
				m.UpstreamBindConfig = &core.BindConfig{}
			}
			if err := m.UpstreamBindConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoadStatsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LoadStatsConfig == nil {
				m.LoadStatsConfig = &core.ApiConfigSource{}
			}
			if err := m.LoadStatsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *ClusterManager_OutlierDetection) 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 ErrIntOverflowBootstrap
			}
			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: OutlierDetection: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutlierDetection: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventLogPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventLogPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *Watchdog) 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 ErrIntOverflowBootstrap
			}
			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: Watchdog: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Watchdog: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MissTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MissTimeout == nil {
				m.MissTimeout = &types.Duration{}
			}
			if err := m.MissTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MegamissTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MegamissTimeout == nil {
				m.MegamissTimeout = &types.Duration{}
			}
			if err := m.MegamissTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KillTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KillTimeout == nil {
				m.KillTimeout = &types.Duration{}
			}
			if err := m.KillTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultikillTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MultikillTimeout == nil {
				m.MultikillTimeout = &types.Duration{}
			}
			if err := m.MultikillTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *Runtime) 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 ErrIntOverflowBootstrap
			}
			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: Runtime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Runtime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymlinkRoot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymlinkRoot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subdirectory", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subdirectory = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OverrideSubdirectory", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OverrideSubdirectory = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Base == nil {
				m.Base = &types.Struct{}
			}
			if err := m.Base.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *RuntimeLayer) 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 ErrIntOverflowBootstrap
			}
			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: RuntimeLayer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RuntimeLayer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StaticLayer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Struct{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.LayerSpecifier = &RuntimeLayer_StaticLayer{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiskLayer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RuntimeLayer_DiskLayer{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.LayerSpecifier = &RuntimeLayer_DiskLayer_{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminLayer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RuntimeLayer_AdminLayer{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.LayerSpecifier = &RuntimeLayer_AdminLayer_{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RtdsLayer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RuntimeLayer_RtdsLayer{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.LayerSpecifier = &RuntimeLayer_RtdsLayer_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *RuntimeLayer_DiskLayer) 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 ErrIntOverflowBootstrap
			}
			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: DiskLayer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DiskLayer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymlinkRoot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymlinkRoot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppendServiceCluster", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AppendServiceCluster = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subdirectory", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subdirectory = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *RuntimeLayer_AdminLayer) 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 ErrIntOverflowBootstrap
			}
			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: AdminLayer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AdminLayer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *RuntimeLayer_RtdsLayer) 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 ErrIntOverflowBootstrap
			}
			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: RtdsLayer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RtdsLayer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				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 ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RtdsConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RtdsConfig == nil {
				m.RtdsConfig = &core.ConfigSource{}
			}
			if err := m.RtdsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 *LayeredRuntime) 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 ErrIntOverflowBootstrap
			}
			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: LayeredRuntime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LayeredRuntime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Layers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBootstrap
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBootstrap
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBootstrap
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Layers = append(m.Layers, &RuntimeLayer{})
			if err := m.Layers[len(m.Layers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBootstrap(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBootstrap
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthBootstrap
			}
			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 skipBootstrap(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, ErrIntOverflowBootstrap
			}
			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, ErrIntOverflowBootstrap
				}
				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, ErrIntOverflowBootstrap
				}
				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, ErrInvalidLengthBootstrap
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthBootstrap
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowBootstrap
					}
					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 := skipBootstrap(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthBootstrap
				}
			}
			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 (
	ErrInvalidLengthBootstrap = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBootstrap   = fmt.Errorf("proto: integer overflow")
)