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

package v2

import (
	fmt "fmt"
	v2 "github.com/envoyproxy/go-control-plane/envoy/api/v2"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v2/core"
	v21 "github.com/envoyproxy/go-control-plane/envoy/config/filter/accesslog/v2"
	_type "github.com/envoyproxy/go-control-plane/envoy/type"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	time "time"
)

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

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

type HttpConnectionManager_CodecType int32

const (
	// For every new connection, the connection manager will determine which
	// codec to use. This mode supports both ALPN for TLS listeners as well as
	// protocol inference for plaintext listeners. If ALPN data is available, it
	// is preferred, otherwise protocol inference is used. In almost all cases,
	// this is the right option to choose for this setting.
	AUTO HttpConnectionManager_CodecType = 0
	// The connection manager will assume that the client is speaking HTTP/1.1.
	HTTP1 HttpConnectionManager_CodecType = 1
	// The connection manager will assume that the client is speaking HTTP/2
	// (Envoy does not require HTTP/2 to take place over TLS or to use ALPN.
	// Prior knowledge is allowed).
	HTTP2 HttpConnectionManager_CodecType = 2
)

var HttpConnectionManager_CodecType_name = map[int32]string{
	0: "AUTO",
	1: "HTTP1",
	2: "HTTP2",
}

var HttpConnectionManager_CodecType_value = map[string]int32{
	"AUTO":  0,
	"HTTP1": 1,
	"HTTP2": 2,
}

func (x HttpConnectionManager_CodecType) String() string {
	return proto.EnumName(HttpConnectionManager_CodecType_name, int32(x))
}

func (HttpConnectionManager_CodecType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8fe65268985a88f7, []int{0, 0}
}

// How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP
// header.
type HttpConnectionManager_ForwardClientCertDetails int32

const (
	// Do not send the XFCC header to the next hop. This is the default value.
	SANITIZE HttpConnectionManager_ForwardClientCertDetails = 0
	// When the client connection is mTLS (Mutual TLS), forward the XFCC header
	// in the request.
	FORWARD_ONLY HttpConnectionManager_ForwardClientCertDetails = 1
	// When the client connection is mTLS, append the client certificate
	// information to the request’s XFCC header and forward it.
	APPEND_FORWARD HttpConnectionManager_ForwardClientCertDetails = 2
	// When the client connection is mTLS, reset the XFCC header with the client
	// certificate information and send it to the next hop.
	SANITIZE_SET HttpConnectionManager_ForwardClientCertDetails = 3
	// Always forward the XFCC header in the request, regardless of whether the
	// client connection is mTLS.
	ALWAYS_FORWARD_ONLY HttpConnectionManager_ForwardClientCertDetails = 4
)

var HttpConnectionManager_ForwardClientCertDetails_name = map[int32]string{
	0: "SANITIZE",
	1: "FORWARD_ONLY",
	2: "APPEND_FORWARD",
	3: "SANITIZE_SET",
	4: "ALWAYS_FORWARD_ONLY",
}

var HttpConnectionManager_ForwardClientCertDetails_value = map[string]int32{
	"SANITIZE":            0,
	"FORWARD_ONLY":        1,
	"APPEND_FORWARD":      2,
	"SANITIZE_SET":        3,
	"ALWAYS_FORWARD_ONLY": 4,
}

func (x HttpConnectionManager_ForwardClientCertDetails) String() string {
	return proto.EnumName(HttpConnectionManager_ForwardClientCertDetails_name, int32(x))
}

func (HttpConnectionManager_ForwardClientCertDetails) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8fe65268985a88f7, []int{0, 1}
}

// [#comment:TODO(kyessenov): Align this field with listener traffic direction field.]
type HttpConnectionManager_Tracing_OperationName int32

const (
	// The HTTP listener is used for ingress/incoming requests.
	INGRESS HttpConnectionManager_Tracing_OperationName = 0
	// The HTTP listener is used for egress/outgoing requests.
	EGRESS HttpConnectionManager_Tracing_OperationName = 1
)

var HttpConnectionManager_Tracing_OperationName_name = map[int32]string{
	0: "INGRESS",
	1: "EGRESS",
}

var HttpConnectionManager_Tracing_OperationName_value = map[string]int32{
	"INGRESS": 0,
	"EGRESS":  1,
}

func (x HttpConnectionManager_Tracing_OperationName) String() string {
	return proto.EnumName(HttpConnectionManager_Tracing_OperationName_name, int32(x))
}

func (HttpConnectionManager_Tracing_OperationName) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8fe65268985a88f7, []int{0, 0, 0}
}

// [#comment:next free field: 34]
type HttpConnectionManager struct {
	// Supplies the type of codec that the connection manager should use.
	CodecType HttpConnectionManager_CodecType `protobuf:"varint,1,opt,name=codec_type,json=codecType,proto3,enum=envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager_CodecType" json:"codec_type,omitempty"`
	// The human readable prefix to use when emitting statistics for the
	// connection manager. See the :ref:`statistics documentation <config_http_conn_man_stats>` for
	// more information.
	StatPrefix string `protobuf:"bytes,2,opt,name=stat_prefix,json=statPrefix,proto3" json:"stat_prefix,omitempty"`
	// Types that are valid to be assigned to RouteSpecifier:
	//	*HttpConnectionManager_Rds
	//	*HttpConnectionManager_RouteConfig
	//	*HttpConnectionManager_ScopedRoutes
	RouteSpecifier isHttpConnectionManager_RouteSpecifier `protobuf_oneof:"route_specifier"`
	// A list of individual HTTP filters that make up the filter chain for
	// requests made to the connection manager. Order matters as the filters are
	// processed sequentially as request events happen.
	HttpFilters []*HttpFilter `protobuf:"bytes,5,rep,name=http_filters,json=httpFilters,proto3" json:"http_filters,omitempty"`
	// Whether the connection manager manipulates the :ref:`config_http_conn_man_headers_user-agent`
	// and :ref:`config_http_conn_man_headers_downstream-service-cluster` headers. See the linked
	// documentation for more information. Defaults to false.
	AddUserAgent *types.BoolValue `protobuf:"bytes,6,opt,name=add_user_agent,json=addUserAgent,proto3" json:"add_user_agent,omitempty"`
	// Presence of the object defines whether the connection manager
	// emits :ref:`tracing <arch_overview_tracing>` data to the :ref:`configured tracing provider
	// <envoy_api_msg_config.trace.v2.Tracing>`.
	Tracing *HttpConnectionManager_Tracing `protobuf:"bytes,7,opt,name=tracing,proto3" json:"tracing,omitempty"`
	// Additional HTTP/1 settings that are passed to the HTTP/1 codec.
	HttpProtocolOptions *core.Http1ProtocolOptions `protobuf:"bytes,8,opt,name=http_protocol_options,json=httpProtocolOptions,proto3" json:"http_protocol_options,omitempty"`
	// Additional HTTP/2 settings that are passed directly to the HTTP/2 codec.
	Http2ProtocolOptions *core.Http2ProtocolOptions `protobuf:"bytes,9,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	// An optional override that the connection manager will write to the server
	// header in responses. If not set, the default is *envoy*.
	ServerName string `protobuf:"bytes,10,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	// The maximum request headers size for incoming connections.
	// If unconfigured, the default max request headers allowed is 60 KiB.
	// Requests that exceed this limit will receive a 431 response.
	// The max configurable limit is 96 KiB, based on current implementation
	// constraints.
	MaxRequestHeadersKb *types.UInt32Value `protobuf:"bytes,29,opt,name=max_request_headers_kb,json=maxRequestHeadersKb,proto3" json:"max_request_headers_kb,omitempty"`
	// The idle timeout for connections managed by the connection manager. The
	// idle timeout is defined as the period in which there are no active
	// requests. If not set, there is no idle timeout. When the idle timeout is
	// reached the connection will be closed. If the connection is an HTTP/2
	// connection a drain sequence will occur prior to closing the connection. See
	// :ref:`drain_timeout
	// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.drain_timeout>`.
	IdleTimeout *time.Duration `protobuf:"bytes,11,opt,name=idle_timeout,json=idleTimeout,proto3,stdduration" json:"idle_timeout,omitempty"`
	// The stream idle timeout for connections managed by the connection manager.
	// If not specified, this defaults to 5 minutes. The default value was selected
	// so as not to interfere with any smaller configured timeouts that may have
	// existed in configurations prior to the introduction of this feature, while
	// introducing robustness to TCP connections that terminate without a FIN.
	//
	// This idle timeout applies to new streams and is overridable by the
	// :ref:`route-level idle_timeout
	// <envoy_api_field_route.RouteAction.idle_timeout>`. Even on a stream in
	// which the override applies, prior to receipt of the initial request
	// headers, the :ref:`stream_idle_timeout
	// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.stream_idle_timeout>`
	// applies. Each time an encode/decode event for headers or data is processed
	// for the stream, the timer will be reset. If the timeout fires, the stream
	// is terminated with a 408 Request Timeout error code if no upstream response
	// header has been received, otherwise a stream reset occurs.
	//
	// Note that it is possible to idle timeout even if the wire traffic for a stream is non-idle, due
	// to the granularity of events presented to the connection manager. For example, while receiving
	// very large request headers, it may be the case that there is traffic regularly arriving on the
	// wire while the connection manage is only able to observe the end-of-headers event, hence the
	// stream may still idle timeout.
	//
	// A value of 0 will completely disable the connection manager stream idle
	// timeout, although per-route idle timeout overrides will continue to apply.
	StreamIdleTimeout *time.Duration `protobuf:"bytes,24,opt,name=stream_idle_timeout,json=streamIdleTimeout,proto3,stdduration" json:"stream_idle_timeout,omitempty"`
	// A timeout for idle requests managed by the connection manager.
	// The timer is activated when the request is initiated, and is disarmed when the last byte of the
	// request is sent upstream (i.e. all decoding filters have processed the request), OR when the
	// response is initiated. If not specified or set to 0, this timeout is disabled.
	RequestTimeout *time.Duration `protobuf:"bytes,28,opt,name=request_timeout,json=requestTimeout,proto3,stdduration" json:"request_timeout,omitempty"`
	// The time that Envoy will wait between sending an HTTP/2 “shutdown
	// notification” (GOAWAY frame with max stream ID) and a final GOAWAY frame.
	// This is used so that Envoy provides a grace period for new streams that
	// race with the final GOAWAY frame. During this grace period, Envoy will
	// continue to accept new streams. After the grace period, a final GOAWAY
	// frame is sent and Envoy will start refusing new streams. Draining occurs
	// both when a connection hits the idle timeout or during general server
	// draining. The default grace period is 5000 milliseconds (5 seconds) if this
	// option is not specified.
	DrainTimeout *time.Duration `protobuf:"bytes,12,opt,name=drain_timeout,json=drainTimeout,proto3,stdduration" json:"drain_timeout,omitempty"`
	// The delayed close timeout is for downstream connections managed by the HTTP connection manager.
	// It is defined as a grace period after connection close processing has been locally initiated
	// during which Envoy will wait for the peer to close (i.e., a TCP FIN/RST is received by Envoy
	// from the downstream connection) prior to Envoy closing the socket associated with that
	// connection.
	// NOTE: This timeout is enforced even when the socket associated with the downstream connection
	// is pending a flush of the write buffer. However, any progress made writing data to the socket
	// will restart the timer associated with this timeout. This means that the total grace period for
	// a socket in this state will be
	// <total_time_waiting_for_write_buffer_flushes>+<delayed_close_timeout>.
	//
	// Delaying Envoy's connection close and giving the peer the opportunity to initiate the close
	// sequence mitigates a race condition that exists when downstream clients do not drain/process
	// data in a connection's receive buffer after a remote close has been detected via a socket
	// write(). This race leads to such clients failing to process the response code sent by Envoy,
	// which could result in erroneous downstream processing.
	//
	// If the timeout triggers, Envoy will close the connection's socket.
	//
	// The default timeout is 1000 ms if this option is not specified.
	//
	// .. NOTE::
	//    To be useful in avoiding the race condition described above, this timeout must be set
	//    to *at least* <max round trip time expected between clients and Envoy>+<100ms to account for
	//    a reasonsable "worst" case processing time for a full iteration of Envoy's event loop>.
	//
	// .. WARNING::
	//    A value of 0 will completely disable delayed close processing. When disabled, the downstream
	//    connection's socket will be closed immediately after the write flush is completed or will
	//    never close if the write flush does not complete.
	DelayedCloseTimeout *time.Duration `protobuf:"bytes,26,opt,name=delayed_close_timeout,json=delayedCloseTimeout,proto3,stdduration" json:"delayed_close_timeout,omitempty"`
	// Configuration for :ref:`HTTP access logs <arch_overview_access_logs>`
	// emitted by the connection manager.
	AccessLog []*v21.AccessLog `protobuf:"bytes,13,rep,name=access_log,json=accessLog,proto3" json:"access_log,omitempty"`
	// If set to true, the connection manager will use the real remote address
	// of the client connection when determining internal versus external origin and manipulating
	// various headers. If set to false or absent, the connection manager will use the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. See the documentation for
	// :ref:`config_http_conn_man_headers_x-forwarded-for`,
	// :ref:`config_http_conn_man_headers_x-envoy-internal`, and
	// :ref:`config_http_conn_man_headers_x-envoy-external-address` for more information.
	UseRemoteAddress *types.BoolValue `protobuf:"bytes,14,opt,name=use_remote_address,json=useRemoteAddress,proto3" json:"use_remote_address,omitempty"`
	// The number of additional ingress proxy hops from the right side of the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header to trust when
	// determining the origin client's IP address. The default is zero if this option
	// is not specified. See the documentation for
	// :ref:`config_http_conn_man_headers_x-forwarded-for` for more information.
	XffNumTrustedHops uint32 `protobuf:"varint,19,opt,name=xff_num_trusted_hops,json=xffNumTrustedHops,proto3" json:"xff_num_trusted_hops,omitempty"`
	// Configures what network addresses are considered internal for stats and header sanitation
	// purposes. If unspecified, only RFC1918 IP addresses will be considered internal.
	// See the documentation for :ref:`config_http_conn_man_headers_x-envoy-internal` for more
	// information about internal/external addresses.
	InternalAddressConfig *HttpConnectionManager_InternalAddressConfig `protobuf:"bytes,25,opt,name=internal_address_config,json=internalAddressConfig,proto3" json:"internal_address_config,omitempty"`
	// If set, Envoy will not append the remote address to the
	// :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. This may be used in
	// conjunction with HTTP filters that explicitly manipulate XFF after the HTTP connection manager
	// has mutated the request headers. While :ref:`use_remote_address
	// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.use_remote_address>`
	// will also suppress XFF addition, it has consequences for logging and other
	// Envoy uses of the remote address, so *skip_xff_append* should be used
	// when only an elision of XFF addition is intended.
	SkipXffAppend bool `protobuf:"varint,21,opt,name=skip_xff_append,json=skipXffAppend,proto3" json:"skip_xff_append,omitempty"`
	// Via header value to append to request and response headers. If this is
	// empty, no via header will be appended.
	Via string `protobuf:"bytes,22,opt,name=via,proto3" json:"via,omitempty"`
	// Whether the connection manager will generate the :ref:`x-request-id
	// <config_http_conn_man_headers_x-request-id>` header if it does not exist. This defaults to
	// true. Generating a random UUID4 is expensive so in high throughput scenarios where this feature
	// is not desired it can be disabled.
	GenerateRequestId *types.BoolValue `protobuf:"bytes,15,opt,name=generate_request_id,json=generateRequestId,proto3" json:"generate_request_id,omitempty"`
	// Whether the connection manager will keep the :ref:`x-request-id
	// <config_http_conn_man_headers_x-request-id>` header if passed for a request that is edge
	// (Edge request is the request from external clients to front Envoy) and not reset it, which
	// is the current Envoy behaviour. This defaults to false.
	PreserveExternalRequestId bool `protobuf:"varint,32,opt,name=preserve_external_request_id,json=preserveExternalRequestId,proto3" json:"preserve_external_request_id,omitempty"`
	// How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP
	// header.
	ForwardClientCertDetails HttpConnectionManager_ForwardClientCertDetails `protobuf:"varint,16,opt,name=forward_client_cert_details,json=forwardClientCertDetails,proto3,enum=envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager_ForwardClientCertDetails" json:"forward_client_cert_details,omitempty"`
	// This field is valid only when :ref:`forward_client_cert_details
	// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.forward_client_cert_details>`
	// is APPEND_FORWARD or SANITIZE_SET and the client connection is mTLS. It specifies the fields in
	// the client certificate to be forwarded. Note that in the
	// :ref:`config_http_conn_man_headers_x-forwarded-client-cert` header, *Hash* is always set, and
	// *By* is always set when the client certificate presents the URI type Subject Alternative Name
	// value.
	SetCurrentClientCertDetails *HttpConnectionManager_SetCurrentClientCertDetails `protobuf:"bytes,17,opt,name=set_current_client_cert_details,json=setCurrentClientCertDetails,proto3" json:"set_current_client_cert_details,omitempty"`
	// If proxy_100_continue is true, Envoy will proxy incoming "Expect:
	// 100-continue" headers upstream, and forward "100 Continue" responses
	// downstream. If this is false or not set, Envoy will instead strip the
	// "Expect: 100-continue" header, and send a "100 Continue" response itself.
	Proxy_100Continue bool `protobuf:"varint,18,opt,name=proxy_100_continue,json=proxy100Continue,proto3" json:"proxy_100_continue,omitempty"`
	// If
	// :ref:`use_remote_address
	// <envoy_api_field_config.filter.network.http_connection_manager.v2.HttpConnectionManager.use_remote_address>`
	// is true and represent_ipv4_remote_address_as_ipv4_mapped_ipv6 is true and the remote address is
	// an IPv4 address, the address will be mapped to IPv6 before it is appended to *x-forwarded-for*.
	// This is useful for testing compatibility of upstream services that parse the header value. For
	// example, 50.0.0.1 is represented as ::FFFF:50.0.0.1. See `IPv4-Mapped IPv6 Addresses
	// <https://tools.ietf.org/html/rfc4291#section-2.5.5.2>`_ for details. This will also affect the
	// :ref:`config_http_conn_man_headers_x-envoy-external-address` header. See
	// :ref:`http_connection_manager.represent_ipv4_remote_address_as_ipv4_mapped_ipv6
	// <config_http_conn_man_runtime_represent_ipv4_remote_address_as_ipv4_mapped_ipv6>` for runtime
	// control.
	// [#not-implemented-hide:]
	RepresentIpv4RemoteAddressAsIpv4MappedIpv6 bool                                   `protobuf:"varint,20,opt,name=represent_ipv4_remote_address_as_ipv4_mapped_ipv6,json=representIpv4RemoteAddressAsIpv4MappedIpv6,proto3" json:"represent_ipv4_remote_address_as_ipv4_mapped_ipv6,omitempty"`
	UpgradeConfigs                             []*HttpConnectionManager_UpgradeConfig `protobuf:"bytes,23,rep,name=upgrade_configs,json=upgradeConfigs,proto3" json:"upgrade_configs,omitempty"`
	// Should paths be normalized according to RFC 3986 before any processing of
	// requests by HTTP filters or routing? This affects the upstream *:path* header
	// as well. For paths that fail this check, Envoy will respond with 400 to
	// paths that are malformed. This defaults to false currently but will default
	// true in the future. When not specified, this value may be overridden by the
	// runtime variable
	// :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
	// See `Normalization and Comparison <https://tools.ietf.org/html/rfc3986#section-6>`
	// for details of normalization.
	// Note that Envoy does not perform
	// `case normalization <https://tools.ietf.org/html/rfc3986#section-6.2.2.1>`
	NormalizePath *types.BoolValue `protobuf:"bytes,30,opt,name=normalize_path,json=normalizePath,proto3" json:"normalize_path,omitempty"`
	// Determines if adjacent slashes in the path are merged into one before any processing of
	// requests by HTTP filters or routing. This affects the upstream *:path* header as well. Without
	// setting this option, incoming requests with path `//dir///file` will not match against route
	// with `prefix` match set to `/dir`. Defaults to `false`. Note that slash merging is not part of
	// `HTTP spec <https://tools.ietf.org/html/rfc3986>` and is provided for convenience.
	MergeSlashes         bool     `protobuf:"varint,33,opt,name=merge_slashes,json=mergeSlashes,proto3" json:"merge_slashes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HttpConnectionManager proto.InternalMessageInfo

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

type HttpConnectionManager_Rds struct {
	Rds *Rds `protobuf:"bytes,3,opt,name=rds,proto3,oneof"`
}
type HttpConnectionManager_RouteConfig struct {
	RouteConfig *v2.RouteConfiguration `protobuf:"bytes,4,opt,name=route_config,json=routeConfig,proto3,oneof"`
}
type HttpConnectionManager_ScopedRoutes struct {
	ScopedRoutes *ScopedRoutes `protobuf:"bytes,31,opt,name=scoped_routes,json=scopedRoutes,proto3,oneof"`
}

func (*HttpConnectionManager_Rds) isHttpConnectionManager_RouteSpecifier()          {}
func (*HttpConnectionManager_RouteConfig) isHttpConnectionManager_RouteSpecifier()  {}
func (*HttpConnectionManager_ScopedRoutes) isHttpConnectionManager_RouteSpecifier() {}

func (m *HttpConnectionManager) GetRouteSpecifier() isHttpConnectionManager_RouteSpecifier {
	if m != nil {
		return m.RouteSpecifier
	}
	return nil
}

func (m *HttpConnectionManager) GetCodecType() HttpConnectionManager_CodecType {
	if m != nil {
		return m.CodecType
	}
	return AUTO
}

func (m *HttpConnectionManager) GetStatPrefix() string {
	if m != nil {
		return m.StatPrefix
	}
	return ""
}

func (m *HttpConnectionManager) GetRds() *Rds {
	if x, ok := m.GetRouteSpecifier().(*HttpConnectionManager_Rds); ok {
		return x.Rds
	}
	return nil
}

func (m *HttpConnectionManager) GetRouteConfig() *v2.RouteConfiguration {
	if x, ok := m.GetRouteSpecifier().(*HttpConnectionManager_RouteConfig); ok {
		return x.RouteConfig
	}
	return nil
}

func (m *HttpConnectionManager) GetScopedRoutes() *ScopedRoutes {
	if x, ok := m.GetRouteSpecifier().(*HttpConnectionManager_ScopedRoutes); ok {
		return x.ScopedRoutes
	}
	return nil
}

func (m *HttpConnectionManager) GetHttpFilters() []*HttpFilter {
	if m != nil {
		return m.HttpFilters
	}
	return nil
}

func (m *HttpConnectionManager) GetAddUserAgent() *types.BoolValue {
	if m != nil {
		return m.AddUserAgent
	}
	return nil
}

func (m *HttpConnectionManager) GetTracing() *HttpConnectionManager_Tracing {
	if m != nil {
		return m.Tracing
	}
	return nil
}

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

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

func (m *HttpConnectionManager) GetServerName() string {
	if m != nil {
		return m.ServerName
	}
	return ""
}

func (m *HttpConnectionManager) GetMaxRequestHeadersKb() *types.UInt32Value {
	if m != nil {
		return m.MaxRequestHeadersKb
	}
	return nil
}

func (m *HttpConnectionManager) GetIdleTimeout() *time.Duration {
	if m != nil {
		return m.IdleTimeout
	}
	return nil
}

func (m *HttpConnectionManager) GetStreamIdleTimeout() *time.Duration {
	if m != nil {
		return m.StreamIdleTimeout
	}
	return nil
}

func (m *HttpConnectionManager) GetRequestTimeout() *time.Duration {
	if m != nil {
		return m.RequestTimeout
	}
	return nil
}

func (m *HttpConnectionManager) GetDrainTimeout() *time.Duration {
	if m != nil {
		return m.DrainTimeout
	}
	return nil
}

func (m *HttpConnectionManager) GetDelayedCloseTimeout() *time.Duration {
	if m != nil {
		return m.DelayedCloseTimeout
	}
	return nil
}

func (m *HttpConnectionManager) GetAccessLog() []*v21.AccessLog {
	if m != nil {
		return m.AccessLog
	}
	return nil
}

func (m *HttpConnectionManager) GetUseRemoteAddress() *types.BoolValue {
	if m != nil {
		return m.UseRemoteAddress
	}
	return nil
}

func (m *HttpConnectionManager) GetXffNumTrustedHops() uint32 {
	if m != nil {
		return m.XffNumTrustedHops
	}
	return 0
}

func (m *HttpConnectionManager) GetInternalAddressConfig() *HttpConnectionManager_InternalAddressConfig {
	if m != nil {
		return m.InternalAddressConfig
	}
	return nil
}

func (m *HttpConnectionManager) GetSkipXffAppend() bool {
	if m != nil {
		return m.SkipXffAppend
	}
	return false
}

func (m *HttpConnectionManager) GetVia() string {
	if m != nil {
		return m.Via
	}
	return ""
}

func (m *HttpConnectionManager) GetGenerateRequestId() *types.BoolValue {
	if m != nil {
		return m.GenerateRequestId
	}
	return nil
}

func (m *HttpConnectionManager) GetPreserveExternalRequestId() bool {
	if m != nil {
		return m.PreserveExternalRequestId
	}
	return false
}

func (m *HttpConnectionManager) GetForwardClientCertDetails() HttpConnectionManager_ForwardClientCertDetails {
	if m != nil {
		return m.ForwardClientCertDetails
	}
	return SANITIZE
}

func (m *HttpConnectionManager) GetSetCurrentClientCertDetails() *HttpConnectionManager_SetCurrentClientCertDetails {
	if m != nil {
		return m.SetCurrentClientCertDetails
	}
	return nil
}

func (m *HttpConnectionManager) GetProxy_100Continue() bool {
	if m != nil {
		return m.Proxy_100Continue
	}
	return false
}

func (m *HttpConnectionManager) GetRepresentIpv4RemoteAddressAsIpv4MappedIpv6() bool {
	if m != nil {
		return m.RepresentIpv4RemoteAddressAsIpv4MappedIpv6
	}
	return false
}

func (m *HttpConnectionManager) GetUpgradeConfigs() []*HttpConnectionManager_UpgradeConfig {
	if m != nil {
		return m.UpgradeConfigs
	}
	return nil
}

func (m *HttpConnectionManager) GetNormalizePath() *types.BoolValue {
	if m != nil {
		return m.NormalizePath
	}
	return nil
}

func (m *HttpConnectionManager) GetMergeSlashes() bool {
	if m != nil {
		return m.MergeSlashes
	}
	return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*HttpConnectionManager) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _HttpConnectionManager_OneofMarshaler, _HttpConnectionManager_OneofUnmarshaler, _HttpConnectionManager_OneofSizer, []interface{}{
		(*HttpConnectionManager_Rds)(nil),
		(*HttpConnectionManager_RouteConfig)(nil),
		(*HttpConnectionManager_ScopedRoutes)(nil),
	}
}

func _HttpConnectionManager_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*HttpConnectionManager)
	// route_specifier
	switch x := m.RouteSpecifier.(type) {
	case *HttpConnectionManager_Rds:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Rds); err != nil {
			return err
		}
	case *HttpConnectionManager_RouteConfig:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RouteConfig); err != nil {
			return err
		}
	case *HttpConnectionManager_ScopedRoutes:
		_ = b.EncodeVarint(31<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ScopedRoutes); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("HttpConnectionManager.RouteSpecifier has unexpected type %T", x)
	}
	return nil
}

func _HttpConnectionManager_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*HttpConnectionManager)
	switch tag {
	case 3: // route_specifier.rds
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Rds)
		err := b.DecodeMessage(msg)
		m.RouteSpecifier = &HttpConnectionManager_Rds{msg}
		return true, err
	case 4: // route_specifier.route_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(v2.RouteConfiguration)
		err := b.DecodeMessage(msg)
		m.RouteSpecifier = &HttpConnectionManager_RouteConfig{msg}
		return true, err
	case 31: // route_specifier.scoped_routes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ScopedRoutes)
		err := b.DecodeMessage(msg)
		m.RouteSpecifier = &HttpConnectionManager_ScopedRoutes{msg}
		return true, err
	default:
		return false, nil
	}
}

func _HttpConnectionManager_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*HttpConnectionManager)
	// route_specifier
	switch x := m.RouteSpecifier.(type) {
	case *HttpConnectionManager_Rds:
		s := proto.Size(x.Rds)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *HttpConnectionManager_RouteConfig:
		s := proto.Size(x.RouteConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *HttpConnectionManager_ScopedRoutes:
		s := proto.Size(x.ScopedRoutes)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type HttpConnectionManager_Tracing struct {
	// The span name will be derived from this field.
	OperationName HttpConnectionManager_Tracing_OperationName `protobuf:"varint,1,opt,name=operation_name,json=operationName,proto3,enum=envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager_Tracing_OperationName" json:"operation_name,omitempty"`
	// A list of header names used to create tags for the active span. The header name is used to
	// populate the tag name, and the header value is used to populate the tag value. The tag is
	// created if the specified header name is present in the request's headers.
	RequestHeadersForTags []string `protobuf:"bytes,2,rep,name=request_headers_for_tags,json=requestHeadersForTags,proto3" json:"request_headers_for_tags,omitempty"`
	// Target percentage of requests managed by this HTTP connection manager that will be force
	// traced if the :ref:`x-client-trace-id <config_http_conn_man_headers_x-client-trace-id>`
	// header is set. This field is a direct analog for the runtime variable
	// 'tracing.client_sampling' in the :ref:`HTTP Connection Manager
	// <config_http_conn_man_runtime>`.
	// Default: 100%
	ClientSampling *_type.Percent `protobuf:"bytes,3,opt,name=client_sampling,json=clientSampling,proto3" json:"client_sampling,omitempty"`
	// Target percentage of requests managed by this HTTP connection manager that will be randomly
	// selected for trace generation, if not requested by the client or not forced. This field is
	// a direct analog for the runtime variable 'tracing.random_sampling' in the
	// :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
	// Default: 100%
	RandomSampling *_type.Percent `protobuf:"bytes,4,opt,name=random_sampling,json=randomSampling,proto3" json:"random_sampling,omitempty"`
	// Target percentage of requests managed by this HTTP connection manager that will be traced
	// after all other sampling checks have been applied (client-directed, force tracing, random
	// sampling). This field functions as an upper limit on the total configured sampling rate. For
	// instance, setting client_sampling to 100% but overall_sampling to 1% will result in only 1%
	// of client requests with the appropriate headers to be force traced. This field is a direct
	// analog for the runtime variable 'tracing.global_enabled' in the
	// :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
	// Default: 100%
	OverallSampling *_type.Percent `protobuf:"bytes,5,opt,name=overall_sampling,json=overallSampling,proto3" json:"overall_sampling,omitempty"`
	// Whether to annotate spans with additional data. If true, spans will include logs for stream
	// events.
	Verbose              bool     `protobuf:"varint,6,opt,name=verbose,proto3" json:"verbose,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HttpConnectionManager_Tracing proto.InternalMessageInfo

func (m *HttpConnectionManager_Tracing) GetOperationName() HttpConnectionManager_Tracing_OperationName {
	if m != nil {
		return m.OperationName
	}
	return INGRESS
}

func (m *HttpConnectionManager_Tracing) GetRequestHeadersForTags() []string {
	if m != nil {
		return m.RequestHeadersForTags
	}
	return nil
}

func (m *HttpConnectionManager_Tracing) GetClientSampling() *_type.Percent {
	if m != nil {
		return m.ClientSampling
	}
	return nil
}

func (m *HttpConnectionManager_Tracing) GetRandomSampling() *_type.Percent {
	if m != nil {
		return m.RandomSampling
	}
	return nil
}

func (m *HttpConnectionManager_Tracing) GetOverallSampling() *_type.Percent {
	if m != nil {
		return m.OverallSampling
	}
	return nil
}

func (m *HttpConnectionManager_Tracing) GetVerbose() bool {
	if m != nil {
		return m.Verbose
	}
	return false
}

type HttpConnectionManager_InternalAddressConfig struct {
	// Whether unix socket addresses should be considered internal.
	UnixSockets          bool     `protobuf:"varint,1,opt,name=unix_sockets,json=unixSockets,proto3" json:"unix_sockets,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HttpConnectionManager_InternalAddressConfig proto.InternalMessageInfo

func (m *HttpConnectionManager_InternalAddressConfig) GetUnixSockets() bool {
	if m != nil {
		return m.UnixSockets
	}
	return false
}

// [#comment:next free field: 7]
type HttpConnectionManager_SetCurrentClientCertDetails struct {
	// Whether to forward the subject of the client cert. Defaults to false.
	Subject *types.BoolValue `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
	// Whether to forward the entire client cert in URL encoded PEM format. This will appear in the
	// XFCC header comma separated from other values with the value Cert="PEM".
	// Defaults to false.
	Cert bool `protobuf:"varint,3,opt,name=cert,proto3" json:"cert,omitempty"`
	// Whether to forward the entire client cert chain (including the leaf cert) in URL encoded PEM
	// format. This will appear in the XFCC header comma separated from other values with the value
	// Chain="PEM".
	// Defaults to false.
	Chain bool `protobuf:"varint,6,opt,name=chain,proto3" json:"chain,omitempty"`
	// Whether to forward the DNS type Subject Alternative Names of the client cert.
	// Defaults to false.
	Dns bool `protobuf:"varint,4,opt,name=dns,proto3" json:"dns,omitempty"`
	// Whether to forward the URI type Subject Alternative Name of the client cert. Defaults to
	// false.
	Uri                  bool     `protobuf:"varint,5,opt,name=uri,proto3" json:"uri,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HttpConnectionManager_SetCurrentClientCertDetails proto.InternalMessageInfo

func (m *HttpConnectionManager_SetCurrentClientCertDetails) GetSubject() *types.BoolValue {
	if m != nil {
		return m.Subject
	}
	return nil
}

func (m *HttpConnectionManager_SetCurrentClientCertDetails) GetCert() bool {
	if m != nil {
		return m.Cert
	}
	return false
}

func (m *HttpConnectionManager_SetCurrentClientCertDetails) GetChain() bool {
	if m != nil {
		return m.Chain
	}
	return false
}

func (m *HttpConnectionManager_SetCurrentClientCertDetails) GetDns() bool {
	if m != nil {
		return m.Dns
	}
	return false
}

func (m *HttpConnectionManager_SetCurrentClientCertDetails) GetUri() bool {
	if m != nil {
		return m.Uri
	}
	return false
}

// The configuration for HTTP upgrades.
// For each upgrade type desired, an UpgradeConfig must be added.
//
// .. warning::
//
//    The current implementation of upgrade headers does not handle
//    multi-valued upgrade headers. Support for multi-valued headers may be
//    added in the future if needed.
//
// .. warning::
//    The current implementation of upgrade headers does not work with HTTP/2
//    upstreams.
type HttpConnectionManager_UpgradeConfig struct {
	// The case-insensitive name of this upgrade, e.g. "websocket".
	// For each upgrade type present in upgrade_configs, requests with
	// Upgrade: [upgrade_type]
	// will be proxied upstream.
	UpgradeType string `protobuf:"bytes,1,opt,name=upgrade_type,json=upgradeType,proto3" json:"upgrade_type,omitempty"`
	// If present, this represents the filter chain which will be created for
	// this type of upgrade. If no filters are present, the filter chain for
	// HTTP connections will be used for this upgrade type.
	Filters []*HttpFilter `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"`
	// Determines if upgrades are enabled or disabled by default. Defaults to true.
	// This can be overridden on a per-route basis with :ref:`cluster
	// <envoy_api_field_route.RouteAction.upgrade_configs>` as documented in the
	// :ref:`upgrade documentation <arch_overview_websocket>`.
	Enabled              *types.BoolValue `protobuf:"bytes,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_HttpConnectionManager_UpgradeConfig proto.InternalMessageInfo

func (m *HttpConnectionManager_UpgradeConfig) GetUpgradeType() string {
	if m != nil {
		return m.UpgradeType
	}
	return ""
}

func (m *HttpConnectionManager_UpgradeConfig) GetFilters() []*HttpFilter {
	if m != nil {
		return m.Filters
	}
	return nil
}

func (m *HttpConnectionManager_UpgradeConfig) GetEnabled() *types.BoolValue {
	if m != nil {
		return m.Enabled
	}
	return nil
}

type Rds struct {
	// Configuration source specifier for RDS.
	ConfigSource *core.ConfigSource `protobuf:"bytes,1,opt,name=config_source,json=configSource,proto3" json:"config_source,omitempty"`
	// The name of the route configuration. This name will be passed to the RDS
	// API. This allows an Envoy configuration with multiple HTTP listeners (and
	// associated HTTP connection manager filters) to use different route
	// configurations.
	RouteConfigName      string   `protobuf:"bytes,2,opt,name=route_config_name,json=routeConfigName,proto3" json:"route_config_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Rds proto.InternalMessageInfo

func (m *Rds) GetConfigSource() *core.ConfigSource {
	if m != nil {
		return m.ConfigSource
	}
	return nil
}

func (m *Rds) GetRouteConfigName() string {
	if m != nil {
		return m.RouteConfigName
	}
	return ""
}

// This message is used to work around the limitations with 'oneof' and repeated fields.
type ScopedRouteConfigurationsList struct {
	ScopedRouteConfigurations []*v2.ScopedRouteConfiguration `protobuf:"bytes,1,rep,name=scoped_route_configurations,json=scopedRouteConfigurations,proto3" json:"scoped_route_configurations,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                       `json:"-"`
	XXX_unrecognized          []byte                         `json:"-"`
	XXX_sizecache             int32                          `json:"-"`
}

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

var xxx_messageInfo_ScopedRouteConfigurationsList proto.InternalMessageInfo

func (m *ScopedRouteConfigurationsList) GetScopedRouteConfigurations() []*v2.ScopedRouteConfiguration {
	if m != nil {
		return m.ScopedRouteConfigurations
	}
	return nil
}

type ScopedRoutes struct {
	// The name assigned to the scoped routing configuration.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The algorithm to use for constructing a scope key for each request.
	ScopeKeyBuilder *ScopedRoutes_ScopeKeyBuilder `protobuf:"bytes,2,opt,name=scope_key_builder,json=scopeKeyBuilder,proto3" json:"scope_key_builder,omitempty"`
	// Configuration source specifier for RDS.
	// This config source is used to subscribe to RouteConfiguration resources specified in
	// ScopedRouteConfiguration messages.
	RdsConfigSource *core.ConfigSource `protobuf:"bytes,3,opt,name=rds_config_source,json=rdsConfigSource,proto3" json:"rds_config_source,omitempty"`
	// Types that are valid to be assigned to ConfigSpecifier:
	//	*ScopedRoutes_ScopedRouteConfigurationsList
	//	*ScopedRoutes_ScopedRds
	ConfigSpecifier      isScopedRoutes_ConfigSpecifier `protobuf_oneof:"config_specifier"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

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

var xxx_messageInfo_ScopedRoutes proto.InternalMessageInfo

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

type ScopedRoutes_ScopedRouteConfigurationsList struct {
	ScopedRouteConfigurationsList *ScopedRouteConfigurationsList `protobuf:"bytes,4,opt,name=scoped_route_configurations_list,json=scopedRouteConfigurationsList,proto3,oneof"`
}
type ScopedRoutes_ScopedRds struct {
	ScopedRds *ScopedRds `protobuf:"bytes,5,opt,name=scoped_rds,json=scopedRds,proto3,oneof"`
}

func (*ScopedRoutes_ScopedRouteConfigurationsList) isScopedRoutes_ConfigSpecifier() {}
func (*ScopedRoutes_ScopedRds) isScopedRoutes_ConfigSpecifier()                     {}

func (m *ScopedRoutes) GetConfigSpecifier() isScopedRoutes_ConfigSpecifier {
	if m != nil {
		return m.ConfigSpecifier
	}
	return nil
}

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

func (m *ScopedRoutes) GetScopeKeyBuilder() *ScopedRoutes_ScopeKeyBuilder {
	if m != nil {
		return m.ScopeKeyBuilder
	}
	return nil
}

func (m *ScopedRoutes) GetRdsConfigSource() *core.ConfigSource {
	if m != nil {
		return m.RdsConfigSource
	}
	return nil
}

func (m *ScopedRoutes) GetScopedRouteConfigurationsList() *ScopedRouteConfigurationsList {
	if x, ok := m.GetConfigSpecifier().(*ScopedRoutes_ScopedRouteConfigurationsList); ok {
		return x.ScopedRouteConfigurationsList
	}
	return nil
}

func (m *ScopedRoutes) GetScopedRds() *ScopedRds {
	if x, ok := m.GetConfigSpecifier().(*ScopedRoutes_ScopedRds); ok {
		return x.ScopedRds
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ScopedRoutes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ScopedRoutes_OneofMarshaler, _ScopedRoutes_OneofUnmarshaler, _ScopedRoutes_OneofSizer, []interface{}{
		(*ScopedRoutes_ScopedRouteConfigurationsList)(nil),
		(*ScopedRoutes_ScopedRds)(nil),
	}
}

func _ScopedRoutes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ScopedRoutes)
	// config_specifier
	switch x := m.ConfigSpecifier.(type) {
	case *ScopedRoutes_ScopedRouteConfigurationsList:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ScopedRouteConfigurationsList); err != nil {
			return err
		}
	case *ScopedRoutes_ScopedRds:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ScopedRds); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ScopedRoutes.ConfigSpecifier has unexpected type %T", x)
	}
	return nil
}

func _ScopedRoutes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ScopedRoutes)
	switch tag {
	case 4: // config_specifier.scoped_route_configurations_list
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ScopedRouteConfigurationsList)
		err := b.DecodeMessage(msg)
		m.ConfigSpecifier = &ScopedRoutes_ScopedRouteConfigurationsList{msg}
		return true, err
	case 5: // config_specifier.scoped_rds
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ScopedRds)
		err := b.DecodeMessage(msg)
		m.ConfigSpecifier = &ScopedRoutes_ScopedRds{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ScopedRoutes_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ScopedRoutes)
	// config_specifier
	switch x := m.ConfigSpecifier.(type) {
	case *ScopedRoutes_ScopedRouteConfigurationsList:
		s := proto.Size(x.ScopedRouteConfigurationsList)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ScopedRoutes_ScopedRds:
		s := proto.Size(x.ScopedRds)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Specifies the mechanism for constructing "scope keys" based on HTTP request attributes. These
// keys are matched against a set of :ref:`Key<envoy_api_msg_ScopedRouteConfiguration.Key>`
// objects assembled from :ref:`ScopedRouteConfiguration<envoy_api_msg_ScopedRouteConfiguration>`
// messages distributed via SRDS (the Scoped Route Discovery Service) or assigned statically via
// :ref:`scoped_route_configurations_list<envoy_api_field_config.filter.network.http_connection_manager.v2.ScopedRoutes.scoped_route_configurations_list>`.
//
// Upon receiving a request's headers, the Router will build a key using the algorithm specified
// by this message. This key will be used to look up the routing table (i.e., the
// :ref:`RouteConfiguration<envoy_api_msg_RouteConfiguration>`) to use for the request.
type ScopedRoutes_ScopeKeyBuilder struct {
	// The final scope key consists of the ordered union of these fragments.
	Fragments            []*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder `protobuf:"bytes,1,rep,name=fragments,proto3" json:"fragments,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                        `json:"-"`
	XXX_unrecognized     []byte                                          `json:"-"`
	XXX_sizecache        int32                                           `json:"-"`
}

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

var xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder proto.InternalMessageInfo

func (m *ScopedRoutes_ScopeKeyBuilder) GetFragments() []*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder {
	if m != nil {
		return m.Fragments
	}
	return nil
}

// Specifies the mechanism for constructing key fragments which are composed into scope keys.
type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder struct {
	// Types that are valid to be assigned to Type:
	//	*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_
	Type                 isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}                                            `json:"-"`
	XXX_unrecognized     []byte                                              `json:"-"`
	XXX_sizecache        int32                                               `json:"-"`
}

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

var xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder proto.InternalMessageInfo

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

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ struct {
	HeaderValueExtractor *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor `protobuf:"bytes,1,opt,name=header_value_extractor,json=headerValueExtractor,proto3,oneof"`
}

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_) isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type() {
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) GetType() isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) GetHeaderValueExtractor() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor {
	if x, ok := m.GetType().(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_); ok {
		return x.HeaderValueExtractor
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_OneofMarshaler, _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_OneofUnmarshaler, _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_OneofSizer, []interface{}{
		(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_)(nil),
	}
}

func _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder)
	// type
	switch x := m.Type.(type) {
	case *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.HeaderValueExtractor); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ScopedRoutes_ScopeKeyBuilder_FragmentBuilder.Type has unexpected type %T", x)
	}
	return nil
}

func _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder)
	switch tag {
	case 1: // type.header_value_extractor
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor)
		err := b.DecodeMessage(msg)
		m.Type = &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder)
	// type
	switch x := m.Type.(type) {
	case *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_:
		s := proto.Size(x.HeaderValueExtractor)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Specifies how the value of a header should be extracted.
// The following example maps the structure of a header to the fields in this message.
//
// .. code::
//
//              <0> <1>   <-- index
//    X-Header: a=b;c=d
//    |         || |
//    |         || \----> <element_separator>
//    |         ||
//    |         |\----> <element.separator>
//    |         |
//    |         \----> <element.key>
//    |
//    \----> <name>
//
//    Each 'a=b' key-value pair constitutes an 'element' of the header field.
type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor struct {
	// The name of the header field to extract the value from.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The element separator (e.g., ';' separates 'a;b;c;d').
	// Default: empty string. This causes the entirety of the header field to be extracted.
	// If this field is set to an empty string and 'index' is used in the oneof below, 'index'
	// must be set to 0.
	ElementSeparator string `protobuf:"bytes,2,opt,name=element_separator,json=elementSeparator,proto3" json:"element_separator,omitempty"`
	// Types that are valid to be assigned to ExtractType:
	//	*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index
	//	*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element
	ExtractType          isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType `protobuf_oneof:"extract_type"`
	XXX_NoUnkeyedLiteral struct{}                                                                        `json:"-"`
	XXX_unrecognized     []byte                                                                          `json:"-"`
	XXX_sizecache        int32                                                                           `json:"-"`
}

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

var xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor proto.InternalMessageInfo

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

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index struct {
	Index uint32 `protobuf:"varint,3,opt,name=index,proto3,oneof"`
}
type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element struct {
	Element *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement `protobuf:"bytes,4,opt,name=element,proto3,oneof"`
}

func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index) isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType() {
}
func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element) isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType() {
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetExtractType() isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType {
	if m != nil {
		return m.ExtractType
	}
	return nil
}

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

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetElementSeparator() string {
	if m != nil {
		return m.ElementSeparator
	}
	return ""
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetIndex() uint32 {
	if x, ok := m.GetExtractType().(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index); ok {
		return x.Index
	}
	return 0
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) GetElement() *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement {
	if x, ok := m.GetExtractType().(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element); ok {
		return x.Element
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_OneofMarshaler, _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_OneofUnmarshaler, _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_OneofSizer, []interface{}{
		(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index)(nil),
		(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element)(nil),
	}
}

func _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor)
	// extract_type
	switch x := m.ExtractType.(type) {
	case *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index:
		_ = b.EncodeVarint(3<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Index))
	case *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Element); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor.ExtractType has unexpected type %T", x)
	}
	return nil
}

func _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor)
	switch tag {
	case 3: // extract_type.index
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.ExtractType = &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index{uint32(x)}
		return true, err
	case 4: // extract_type.element
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement)
		err := b.DecodeMessage(msg)
		m.ExtractType = &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor)
	// extract_type
	switch x := m.ExtractType.(type) {
	case *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Index))
	case *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element:
		s := proto.Size(x.Element)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Specifies a header field's key value pair to match on.
type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement struct {
	// The separator between key and value (e.g., '=' separates 'k=v;...').
	// If an element is an empty string, the element is ignored.
	// If an element contains no separator, the whole element is parsed as key and the
	// fragment value is an empty string.
	// If there are multiple values for a matched key, the first value is returned.
	Separator string `protobuf:"bytes,1,opt,name=separator,proto3" json:"separator,omitempty"`
	// The key to match on.
	Key                  string   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement proto.InternalMessageInfo

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) GetSeparator() string {
	if m != nil {
		return m.Separator
	}
	return ""
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type ScopedRds struct {
	// Configuration source specifier for scoped RDS.
	ScopedRdsConfigSource *core.ConfigSource `protobuf:"bytes,1,opt,name=scoped_rds_config_source,json=scopedRdsConfigSource,proto3" json:"scoped_rds_config_source,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}           `json:"-"`
	XXX_unrecognized      []byte             `json:"-"`
	XXX_sizecache         int32              `json:"-"`
}

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

var xxx_messageInfo_ScopedRds proto.InternalMessageInfo

func (m *ScopedRds) GetScopedRdsConfigSource() *core.ConfigSource {
	if m != nil {
		return m.ScopedRdsConfigSource
	}
	return nil
}

type HttpFilter struct {
	// The name of the filter to instantiate. The name must match a
	// :ref:`supported filter <config_http_filters>`.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Filter specific configuration which depends on the filter being instantiated. See the supported
	// filters for further documentation.
	//
	// Types that are valid to be assigned to ConfigType:
	//	*HttpFilter_Config
	//	*HttpFilter_TypedConfig
	ConfigType           isHttpFilter_ConfigType `protobuf_oneof:"config_type"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

var xxx_messageInfo_HttpFilter proto.InternalMessageInfo

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

type HttpFilter_Config struct {
	Config *types.Struct `protobuf:"bytes,2,opt,name=config,proto3,oneof"`
}
type HttpFilter_TypedConfig struct {
	TypedConfig *types.Any `protobuf:"bytes,4,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

func (*HttpFilter_Config) isHttpFilter_ConfigType()      {}
func (*HttpFilter_TypedConfig) isHttpFilter_ConfigType() {}

func (m *HttpFilter) GetConfigType() isHttpFilter_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

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

func (m *HttpFilter) GetConfig() *types.Struct {
	if x, ok := m.GetConfigType().(*HttpFilter_Config); ok {
		return x.Config
	}
	return nil
}

func (m *HttpFilter) GetTypedConfig() *types.Any {
	if x, ok := m.GetConfigType().(*HttpFilter_TypedConfig); ok {
		return x.TypedConfig
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*HttpFilter) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _HttpFilter_OneofMarshaler, _HttpFilter_OneofUnmarshaler, _HttpFilter_OneofSizer, []interface{}{
		(*HttpFilter_Config)(nil),
		(*HttpFilter_TypedConfig)(nil),
	}
}

func _HttpFilter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*HttpFilter)
	// config_type
	switch x := m.ConfigType.(type) {
	case *HttpFilter_Config:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Config); err != nil {
			return err
		}
	case *HttpFilter_TypedConfig:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TypedConfig); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("HttpFilter.ConfigType has unexpected type %T", x)
	}
	return nil
}

func _HttpFilter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*HttpFilter)
	switch tag {
	case 2: // config_type.config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.Struct)
		err := b.DecodeMessage(msg)
		m.ConfigType = &HttpFilter_Config{msg}
		return true, err
	case 4: // config_type.typed_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.Any)
		err := b.DecodeMessage(msg)
		m.ConfigType = &HttpFilter_TypedConfig{msg}
		return true, err
	default:
		return false, nil
	}
}

func _HttpFilter_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*HttpFilter)
	// config_type
	switch x := m.ConfigType.(type) {
	case *HttpFilter_Config:
		s := proto.Size(x.Config)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *HttpFilter_TypedConfig:
		s := proto.Size(x.TypedConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterEnum("envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager_CodecType", HttpConnectionManager_CodecType_name, HttpConnectionManager_CodecType_value)
	proto.RegisterEnum("envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager_ForwardClientCertDetails", HttpConnectionManager_ForwardClientCertDetails_name, HttpConnectionManager_ForwardClientCertDetails_value)
	proto.RegisterEnum("envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager_Tracing_OperationName", HttpConnectionManager_Tracing_OperationName_name, HttpConnectionManager_Tracing_OperationName_value)
	proto.RegisterType((*HttpConnectionManager)(nil), "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager")
	proto.RegisterType((*HttpConnectionManager_Tracing)(nil), "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager.Tracing")
	proto.RegisterType((*HttpConnectionManager_InternalAddressConfig)(nil), "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager.InternalAddressConfig")
	proto.RegisterType((*HttpConnectionManager_SetCurrentClientCertDetails)(nil), "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager.SetCurrentClientCertDetails")
	proto.RegisterType((*HttpConnectionManager_UpgradeConfig)(nil), "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager.UpgradeConfig")
	proto.RegisterType((*Rds)(nil), "envoy.config.filter.network.http_connection_manager.v2.Rds")
	proto.RegisterType((*ScopedRouteConfigurationsList)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRouteConfigurationsList")
	proto.RegisterType((*ScopedRoutes)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes")
	proto.RegisterType((*ScopedRoutes_ScopeKeyBuilder)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder")
	proto.RegisterType((*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder.FragmentBuilder")
	proto.RegisterType((*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder.FragmentBuilder.HeaderValueExtractor")
	proto.RegisterType((*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder.FragmentBuilder.HeaderValueExtractor.KvElement")
	proto.RegisterType((*ScopedRds)(nil), "envoy.config.filter.network.http_connection_manager.v2.ScopedRds")
	proto.RegisterType((*HttpFilter)(nil), "envoy.config.filter.network.http_connection_manager.v2.HttpFilter")
}

func init() {
	proto.RegisterFile("envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.proto", fileDescriptor_8fe65268985a88f7)
}

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

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

func (m *HttpConnectionManager) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.CodecType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.CodecType))
	}
	if len(m.StatPrefix) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.StatPrefix)))
		i += copy(dAtA[i:], m.StatPrefix)
	}
	if m.RouteSpecifier != nil {
		nn1, err := m.RouteSpecifier.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn1
	}
	if len(m.HttpFilters) > 0 {
		for _, msg := range m.HttpFilters {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintHttpConnectionManager(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.AddUserAgent != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.AddUserAgent.Size()))
		n2, err := m.AddUserAgent.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Tracing != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Tracing.Size()))
		n3, err := m.Tracing.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.HttpProtocolOptions != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.HttpProtocolOptions.Size()))
		n4, err := m.HttpProtocolOptions.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.Http2ProtocolOptions != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Http2ProtocolOptions.Size()))
		n5, err := m.Http2ProtocolOptions.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if len(m.ServerName) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.ServerName)))
		i += copy(dAtA[i:], m.ServerName)
	}
	if m.IdleTimeout != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.IdleTimeout)))
		n6, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.IdleTimeout, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.DrainTimeout != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.DrainTimeout)))
		n7, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.DrainTimeout, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if len(m.AccessLog) > 0 {
		for _, msg := range m.AccessLog {
			dAtA[i] = 0x6a
			i++
			i = encodeVarintHttpConnectionManager(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.UseRemoteAddress != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.UseRemoteAddress.Size()))
		n8, err := m.UseRemoteAddress.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.GenerateRequestId != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.GenerateRequestId.Size()))
		n9, err := m.GenerateRequestId.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.ForwardClientCertDetails != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ForwardClientCertDetails))
	}
	if m.SetCurrentClientCertDetails != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.SetCurrentClientCertDetails.Size()))
		n10, err := m.SetCurrentClientCertDetails.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.Proxy_100Continue {
		dAtA[i] = 0x90
		i++
		dAtA[i] = 0x1
		i++
		if m.Proxy_100Continue {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XffNumTrustedHops != 0 {
		dAtA[i] = 0x98
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.XffNumTrustedHops))
	}
	if m.RepresentIpv4RemoteAddressAsIpv4MappedIpv6 {
		dAtA[i] = 0xa0
		i++
		dAtA[i] = 0x1
		i++
		if m.RepresentIpv4RemoteAddressAsIpv4MappedIpv6 {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.SkipXffAppend {
		dAtA[i] = 0xa8
		i++
		dAtA[i] = 0x1
		i++
		if m.SkipXffAppend {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Via) > 0 {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.Via)))
		i += copy(dAtA[i:], m.Via)
	}
	if len(m.UpgradeConfigs) > 0 {
		for _, msg := range m.UpgradeConfigs {
			dAtA[i] = 0xba
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintHttpConnectionManager(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.StreamIdleTimeout != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.StreamIdleTimeout)))
		n11, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.StreamIdleTimeout, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.InternalAddressConfig != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.InternalAddressConfig.Size()))
		n12, err := m.InternalAddressConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.DelayedCloseTimeout != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.DelayedCloseTimeout)))
		n13, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.DelayedCloseTimeout, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.RequestTimeout != nil {
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.RequestTimeout)))
		n14, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.RequestTimeout, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.MaxRequestHeadersKb != nil {
		dAtA[i] = 0xea
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.MaxRequestHeadersKb.Size()))
		n15, err := m.MaxRequestHeadersKb.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.NormalizePath != nil {
		dAtA[i] = 0xf2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.NormalizePath.Size()))
		n16, err := m.NormalizePath.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if m.PreserveExternalRequestId {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x2
		i++
		if m.PreserveExternalRequestId {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.MergeSlashes {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x2
		i++
		if m.MergeSlashes {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *HttpConnectionManager_Rds) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Rds != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Rds.Size()))
		n17, err := m.Rds.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	return i, nil
}
func (m *HttpConnectionManager_RouteConfig) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RouteConfig != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.RouteConfig.Size()))
		n18, err := m.RouteConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	return i, nil
}
func (m *HttpConnectionManager_ScopedRoutes) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ScopedRoutes != nil {
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ScopedRoutes.Size()))
		n19, err := m.ScopedRoutes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	return i, nil
}
func (m *HttpConnectionManager_Tracing) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HttpConnectionManager_Tracing) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OperationName != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.OperationName))
	}
	if len(m.RequestHeadersForTags) > 0 {
		for _, s := range m.RequestHeadersForTags {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.ClientSampling != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ClientSampling.Size()))
		n20, err := m.ClientSampling.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if m.RandomSampling != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.RandomSampling.Size()))
		n21, err := m.RandomSampling.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if m.OverallSampling != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.OverallSampling.Size()))
		n22, err := m.OverallSampling.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	if m.Verbose {
		dAtA[i] = 0x30
		i++
		if m.Verbose {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *HttpConnectionManager_InternalAddressConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.UnixSockets {
		dAtA[i] = 0x8
		i++
		if m.UnixSockets {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *HttpConnectionManager_SetCurrentClientCertDetails) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Subject != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Subject.Size()))
		n23, err := m.Subject.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	if m.Cert {
		dAtA[i] = 0x18
		i++
		if m.Cert {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Dns {
		dAtA[i] = 0x20
		i++
		if m.Dns {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Uri {
		dAtA[i] = 0x28
		i++
		if m.Uri {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Chain {
		dAtA[i] = 0x30
		i++
		if m.Chain {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *HttpConnectionManager_UpgradeConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.UpgradeType) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.UpgradeType)))
		i += copy(dAtA[i:], m.UpgradeType)
	}
	if len(m.Filters) > 0 {
		for _, msg := range m.Filters {
			dAtA[i] = 0x12
			i++
			i = encodeVarintHttpConnectionManager(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Enabled != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Enabled.Size()))
		n24, err := m.Enabled.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Rds) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ConfigSource != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ConfigSource.Size()))
		n25, err := m.ConfigSource.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	if len(m.RouteConfigName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.RouteConfigName)))
		i += copy(dAtA[i:], m.RouteConfigName)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ScopedRouteConfigurationsList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ScopedRouteConfigurations) > 0 {
		for _, msg := range m.ScopedRouteConfigurations {
			dAtA[i] = 0xa
			i++
			i = encodeVarintHttpConnectionManager(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ScopedRoutes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ScopeKeyBuilder != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ScopeKeyBuilder.Size()))
		n26, err := m.ScopeKeyBuilder.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	if m.RdsConfigSource != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.RdsConfigSource.Size()))
		n27, err := m.RdsConfigSource.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	if m.ConfigSpecifier != nil {
		nn28, err := m.ConfigSpecifier.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn28
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ScopedRoutes_ScopedRouteConfigurationsList) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ScopedRouteConfigurationsList != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ScopedRouteConfigurationsList.Size()))
		n29, err := m.ScopedRouteConfigurationsList.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	return i, nil
}
func (m *ScopedRoutes_ScopedRds) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ScopedRds != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ScopedRds.Size()))
		n30, err := m.ScopedRds.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	return i, nil
}
func (m *ScopedRoutes_ScopeKeyBuilder) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScopedRoutes_ScopeKeyBuilder) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Fragments) > 0 {
		for _, msg := range m.Fragments {
			dAtA[i] = 0xa
			i++
			i = encodeVarintHttpConnectionManager(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		nn31, err := m.Type.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn31
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HeaderValueExtractor != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.HeaderValueExtractor.Size()))
		n32, err := m.HeaderValueExtractor.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	return i, nil
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.ElementSeparator) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.ElementSeparator)))
		i += copy(dAtA[i:], m.ElementSeparator)
	}
	if m.ExtractType != nil {
		nn33, err := m.ExtractType.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn33
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x18
	i++
	i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Index))
	return i, nil
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Element != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Element.Size()))
		n34, err := m.Element.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n34
	}
	return i, nil
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Separator) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.Separator)))
		i += copy(dAtA[i:], m.Separator)
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ScopedRds) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ScopedRdsConfigSource != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.ScopedRdsConfigSource.Size()))
		n35, err := m.ScopedRdsConfigSource.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n35
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *HttpFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ConfigType != nil {
		nn36, err := m.ConfigType.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn36
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *HttpFilter_Config) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Config != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.Config.Size()))
		n37, err := m.Config.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n37
	}
	return i, nil
}
func (m *HttpFilter_TypedConfig) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TypedConfig != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintHttpConnectionManager(dAtA, i, uint64(m.TypedConfig.Size()))
		n38, err := m.TypedConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n38
	}
	return i, nil
}
func encodeVarintHttpConnectionManager(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *HttpConnectionManager) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CodecType != 0 {
		n += 1 + sovHttpConnectionManager(uint64(m.CodecType))
	}
	l = len(m.StatPrefix)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.RouteSpecifier != nil {
		n += m.RouteSpecifier.Size()
	}
	if len(m.HttpFilters) > 0 {
		for _, e := range m.HttpFilters {
			l = e.Size()
			n += 1 + l + sovHttpConnectionManager(uint64(l))
		}
	}
	if m.AddUserAgent != nil {
		l = m.AddUserAgent.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.Tracing != nil {
		l = m.Tracing.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.HttpProtocolOptions != nil {
		l = m.HttpProtocolOptions.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.Http2ProtocolOptions != nil {
		l = m.Http2ProtocolOptions.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	l = len(m.ServerName)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.IdleTimeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.IdleTimeout)
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.DrainTimeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.DrainTimeout)
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if len(m.AccessLog) > 0 {
		for _, e := range m.AccessLog {
			l = e.Size()
			n += 1 + l + sovHttpConnectionManager(uint64(l))
		}
	}
	if m.UseRemoteAddress != nil {
		l = m.UseRemoteAddress.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.GenerateRequestId != nil {
		l = m.GenerateRequestId.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.ForwardClientCertDetails != 0 {
		n += 2 + sovHttpConnectionManager(uint64(m.ForwardClientCertDetails))
	}
	if m.SetCurrentClientCertDetails != nil {
		l = m.SetCurrentClientCertDetails.Size()
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.Proxy_100Continue {
		n += 3
	}
	if m.XffNumTrustedHops != 0 {
		n += 2 + sovHttpConnectionManager(uint64(m.XffNumTrustedHops))
	}
	if m.RepresentIpv4RemoteAddressAsIpv4MappedIpv6 {
		n += 3
	}
	if m.SkipXffAppend {
		n += 3
	}
	l = len(m.Via)
	if l > 0 {
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if len(m.UpgradeConfigs) > 0 {
		for _, e := range m.UpgradeConfigs {
			l = e.Size()
			n += 2 + l + sovHttpConnectionManager(uint64(l))
		}
	}
	if m.StreamIdleTimeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.StreamIdleTimeout)
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.InternalAddressConfig != nil {
		l = m.InternalAddressConfig.Size()
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.DelayedCloseTimeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.DelayedCloseTimeout)
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.RequestTimeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.RequestTimeout)
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.MaxRequestHeadersKb != nil {
		l = m.MaxRequestHeadersKb.Size()
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.NormalizePath != nil {
		l = m.NormalizePath.Size()
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.PreserveExternalRequestId {
		n += 3
	}
	if m.MergeSlashes {
		n += 3
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HttpConnectionManager_Rds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Rds != nil {
		l = m.Rds.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *HttpConnectionManager_RouteConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RouteConfig != nil {
		l = m.RouteConfig.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *HttpConnectionManager_ScopedRoutes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScopedRoutes != nil {
		l = m.ScopedRoutes.Size()
		n += 2 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *HttpConnectionManager_Tracing) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OperationName != 0 {
		n += 1 + sovHttpConnectionManager(uint64(m.OperationName))
	}
	if len(m.RequestHeadersForTags) > 0 {
		for _, s := range m.RequestHeadersForTags {
			l = len(s)
			n += 1 + l + sovHttpConnectionManager(uint64(l))
		}
	}
	if m.ClientSampling != nil {
		l = m.ClientSampling.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.RandomSampling != nil {
		l = m.RandomSampling.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.OverallSampling != nil {
		l = m.OverallSampling.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.Verbose {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *HttpConnectionManager_SetCurrentClientCertDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Subject != nil {
		l = m.Subject.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.Cert {
		n += 2
	}
	if m.Dns {
		n += 2
	}
	if m.Uri {
		n += 2
	}
	if m.Chain {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HttpConnectionManager_UpgradeConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UpgradeType)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if len(m.Filters) > 0 {
		for _, e := range m.Filters {
			l = e.Size()
			n += 1 + l + sovHttpConnectionManager(uint64(l))
		}
	}
	if m.Enabled != nil {
		l = m.Enabled.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Rds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ConfigSource != nil {
		l = m.ConfigSource.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	l = len(m.RouteConfigName)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ScopedRoutes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.ScopeKeyBuilder != nil {
		l = m.ScopeKeyBuilder.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.RdsConfigSource != nil {
		l = m.RdsConfigSource.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.ConfigSpecifier != nil {
		n += m.ConfigSpecifier.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ScopedRoutes_ScopedRouteConfigurationsList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScopedRouteConfigurationsList != nil {
		l = m.ScopedRouteConfigurationsList.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *ScopedRoutes_ScopedRds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScopedRds != nil {
		l = m.ScopedRds.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *ScopedRoutes_ScopeKeyBuilder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Fragments) > 0 {
		for _, e := range m.Fragments {
			l = e.Size()
			n += 1 + l + sovHttpConnectionManager(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HeaderValueExtractor != nil {
		l = m.HeaderValueExtractor.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	l = len(m.ElementSeparator)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.ExtractType != nil {
		n += m.ExtractType.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovHttpConnectionManager(uint64(m.Index))
	return n
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Element != nil {
		l = m.Element.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Separator)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *HttpFilter_Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}
func (m *HttpFilter_TypedConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TypedConfig != nil {
		l = m.TypedConfig.Size()
		n += 1 + l + sovHttpConnectionManager(uint64(l))
	}
	return n
}

func sovHttpConnectionManager(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozHttpConnectionManager(x uint64) (n int) {
	return sovHttpConnectionManager(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *HttpConnectionManager) 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 ErrIntOverflowHttpConnectionManager
			}
			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: HttpConnectionManager: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HttpConnectionManager: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CodecType", wireType)
			}
			m.CodecType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CodecType |= HttpConnectionManager_CodecType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatPrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StatPrefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Rds{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.RouteSpecifier = &HttpConnectionManager_Rds{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RouteConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &v2.RouteConfiguration{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.RouteSpecifier = &HttpConnectionManager_RouteConfig{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HttpFilters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HttpFilters = append(m.HttpFilters, &HttpFilter{})
			if err := m.HttpFilters[len(m.HttpFilters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddUserAgent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AddUserAgent == nil {
				m.AddUserAgent = &types.BoolValue{}
			}
			if err := m.AddUserAgent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tracing == nil {
				m.Tracing = &HttpConnectionManager_Tracing{}
			}
			if err := m.Tracing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HttpProtocolOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.HttpProtocolOptions == nil {
				m.HttpProtocolOptions = &core.Http1ProtocolOptions{}
			}
			if err := m.HttpProtocolOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Http2ProtocolOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Http2ProtocolOptions == nil {
				m.Http2ProtocolOptions = &core.Http2ProtocolOptions{}
			}
			if err := m.Http2ProtocolOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdleTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdleTimeout == nil {
				m.IdleTimeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.IdleTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DrainTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DrainTimeout == nil {
				m.DrainTimeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.DrainTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessLog = append(m.AccessLog, &v21.AccessLog{})
			if err := m.AccessLog[len(m.AccessLog)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseRemoteAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UseRemoteAddress == nil {
				m.UseRemoteAddress = &types.BoolValue{}
			}
			if err := m.UseRemoteAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenerateRequestId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GenerateRequestId == nil {
				m.GenerateRequestId = &types.BoolValue{}
			}
			if err := m.GenerateRequestId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForwardClientCertDetails", wireType)
			}
			m.ForwardClientCertDetails = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ForwardClientCertDetails |= HttpConnectionManager_ForwardClientCertDetails(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetCurrentClientCertDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SetCurrentClientCertDetails == nil {
				m.SetCurrentClientCertDetails = &HttpConnectionManager_SetCurrentClientCertDetails{}
			}
			if err := m.SetCurrentClientCertDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proxy_100Continue", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Proxy_100Continue = bool(v != 0)
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field XffNumTrustedHops", wireType)
			}
			m.XffNumTrustedHops = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.XffNumTrustedHops |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepresentIpv4RemoteAddressAsIpv4MappedIpv6", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RepresentIpv4RemoteAddressAsIpv4MappedIpv6 = bool(v != 0)
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipXffAppend", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipXffAppend = bool(v != 0)
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Via", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Via = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpgradeConfigs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpgradeConfigs = append(m.UpgradeConfigs, &HttpConnectionManager_UpgradeConfig{})
			if err := m.UpgradeConfigs[len(m.UpgradeConfigs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamIdleTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StreamIdleTimeout == nil {
				m.StreamIdleTimeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.StreamIdleTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalAddressConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InternalAddressConfig == nil {
				m.InternalAddressConfig = &HttpConnectionManager_InternalAddressConfig{}
			}
			if err := m.InternalAddressConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayedCloseTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DelayedCloseTimeout == nil {
				m.DelayedCloseTimeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.DelayedCloseTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestTimeout == nil {
				m.RequestTimeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.RequestTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRequestHeadersKb", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxRequestHeadersKb == nil {
				m.MaxRequestHeadersKb = &types.UInt32Value{}
			}
			if err := m.MaxRequestHeadersKb.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NormalizePath", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NormalizePath == nil {
				m.NormalizePath = &types.BoolValue{}
			}
			if err := m.NormalizePath.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopedRoutes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScopedRoutes{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.RouteSpecifier = &HttpConnectionManager_ScopedRoutes{v}
			iNdEx = postIndex
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreserveExternalRequestId", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PreserveExternalRequestId = bool(v != 0)
		case 33:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MergeSlashes", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MergeSlashes = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *HttpConnectionManager_Tracing) 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 ErrIntOverflowHttpConnectionManager
			}
			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: Tracing: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tracing: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperationName", wireType)
			}
			m.OperationName = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OperationName |= HttpConnectionManager_Tracing_OperationName(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestHeadersForTags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestHeadersForTags = append(m.RequestHeadersForTags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientSampling", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientSampling == nil {
				m.ClientSampling = &_type.Percent{}
			}
			if err := m.ClientSampling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RandomSampling", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RandomSampling == nil {
				m.RandomSampling = &_type.Percent{}
			}
			if err := m.RandomSampling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OverallSampling", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OverallSampling == nil {
				m.OverallSampling = &_type.Percent{}
			}
			if err := m.OverallSampling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Verbose", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Verbose = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *HttpConnectionManager_InternalAddressConfig) 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 ErrIntOverflowHttpConnectionManager
			}
			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: InternalAddressConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InternalAddressConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnixSockets", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UnixSockets = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *HttpConnectionManager_SetCurrentClientCertDetails) 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 ErrIntOverflowHttpConnectionManager
			}
			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: SetCurrentClientCertDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetCurrentClientCertDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Subject == nil {
				m.Subject = &types.BoolValue{}
			}
			if err := m.Subject.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cert", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Cert = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dns", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Dns = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uri", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Uri = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Chain = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *HttpConnectionManager_UpgradeConfig) 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 ErrIntOverflowHttpConnectionManager
			}
			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: UpgradeConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpgradeConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpgradeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpgradeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filters = append(m.Filters, &HttpFilter{})
			if err := m.Filters[len(m.Filters)-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 Enabled", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Enabled == nil {
				m.Enabled = &types.BoolValue{}
			}
			if err := m.Enabled.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *Rds) 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 ErrIntOverflowHttpConnectionManager
			}
			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: Rds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConfigSource == nil {
				m.ConfigSource = &core.ConfigSource{}
			}
			if err := m.ConfigSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RouteConfigName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RouteConfigName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRouteConfigurationsList) 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 ErrIntOverflowHttpConnectionManager
			}
			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: ScopedRouteConfigurationsList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScopedRouteConfigurationsList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopedRouteConfigurations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScopedRouteConfigurations = append(m.ScopedRouteConfigurations, &v2.ScopedRouteConfiguration{})
			if err := m.ScopedRouteConfigurations[len(m.ScopedRouteConfigurations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRoutes) 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 ErrIntOverflowHttpConnectionManager
			}
			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: ScopedRoutes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScopedRoutes: 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 ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 ScopeKeyBuilder", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScopeKeyBuilder == nil {
				m.ScopeKeyBuilder = &ScopedRoutes_ScopeKeyBuilder{}
			}
			if err := m.ScopeKeyBuilder.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RdsConfigSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RdsConfigSource == nil {
				m.RdsConfigSource = &core.ConfigSource{}
			}
			if err := m.RdsConfigSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopedRouteConfigurationsList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScopedRouteConfigurationsList{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigSpecifier = &ScopedRoutes_ScopedRouteConfigurationsList{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopedRds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScopedRds{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigSpecifier = &ScopedRoutes_ScopedRds{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRoutes_ScopeKeyBuilder) 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 ErrIntOverflowHttpConnectionManager
			}
			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: ScopeKeyBuilder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScopeKeyBuilder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fragments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fragments = append(m.Fragments, &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder{})
			if err := m.Fragments[len(m.Fragments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) 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 ErrIntOverflowHttpConnectionManager
			}
			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: FragmentBuilder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FragmentBuilder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderValueExtractor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) 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 ErrIntOverflowHttpConnectionManager
			}
			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: HeaderValueExtractor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeaderValueExtractor: 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 ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 ElementSeparator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ElementSeparator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExtractType = &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index{v}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Element", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ExtractType = &ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) 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 ErrIntOverflowHttpConnectionManager
			}
			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: KvElement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KvElement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Separator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Separator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *ScopedRds) 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 ErrIntOverflowHttpConnectionManager
			}
			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: ScopedRds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScopedRds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScopedRdsConfigSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScopedRdsConfigSource == nil {
				m.ScopedRdsConfigSource = &core.ConfigSource{}
			}
			if err := m.ScopedRdsConfigSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 *HttpFilter) 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 ErrIntOverflowHttpConnectionManager
			}
			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: HttpFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HttpFilter: 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 ErrIntOverflowHttpConnectionManager
				}
				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 ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Struct{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigType = &HttpFilter_Config{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TypedConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHttpConnectionManager
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Any{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigType = &HttpFilter_TypedConfig{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHttpConnectionManager(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHttpConnectionManager
			}
			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 skipHttpConnectionManager(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, ErrIntOverflowHttpConnectionManager
			}
			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, ErrIntOverflowHttpConnectionManager
				}
				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, ErrIntOverflowHttpConnectionManager
				}
				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, ErrInvalidLengthHttpConnectionManager
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthHttpConnectionManager
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowHttpConnectionManager
					}
					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 := skipHttpConnectionManager(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthHttpConnectionManager
				}
			}
			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 (
	ErrInvalidLengthHttpConnectionManager = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHttpConnectionManager   = fmt.Errorf("proto: integer overflow")
)
