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

package envoy_config_filter_network_http_connection_manager_v3alpha

import (
	fmt "fmt"
	v3alpha "github.com/envoyproxy/go-control-plane/envoy/api/v3alpha"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v3alpha/core"
	v3alpha1 "github.com/envoyproxy/go-control-plane/envoy/config/filter/accesslog/v3alpha"
	v3alpha2 "github.com/envoyproxy/go-control-plane/envoy/type/v3alpha"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	duration "github.com/golang/protobuf/ptypes/duration"
	_ "github.com/golang/protobuf/ptypes/struct"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	math "math"
)

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

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

type HttpConnectionManager_CodecType int32

const (
	HttpConnectionManager_AUTO  HttpConnectionManager_CodecType = 0
	HttpConnectionManager_HTTP1 HttpConnectionManager_CodecType = 1
	HttpConnectionManager_HTTP2 HttpConnectionManager_CodecType = 2
	HttpConnectionManager_HTTP3 HttpConnectionManager_CodecType = 3
)

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

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

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

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

type HttpConnectionManager_ServerHeaderTransformation int32

const (
	HttpConnectionManager_OVERWRITE        HttpConnectionManager_ServerHeaderTransformation = 0
	HttpConnectionManager_APPEND_IF_ABSENT HttpConnectionManager_ServerHeaderTransformation = 1
	HttpConnectionManager_PASS_THROUGH     HttpConnectionManager_ServerHeaderTransformation = 2
)

var HttpConnectionManager_ServerHeaderTransformation_name = map[int32]string{
	0: "OVERWRITE",
	1: "APPEND_IF_ABSENT",
	2: "PASS_THROUGH",
}

var HttpConnectionManager_ServerHeaderTransformation_value = map[string]int32{
	"OVERWRITE":        0,
	"APPEND_IF_ABSENT": 1,
	"PASS_THROUGH":     2,
}

func (x HttpConnectionManager_ServerHeaderTransformation) String() string {
	return proto.EnumName(HttpConnectionManager_ServerHeaderTransformation_name, int32(x))
}

func (HttpConnectionManager_ServerHeaderTransformation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6be8bc92cfb072ca, []int{0, 1}
}

type HttpConnectionManager_ForwardClientCertDetails int32

const (
	HttpConnectionManager_SANITIZE            HttpConnectionManager_ForwardClientCertDetails = 0
	HttpConnectionManager_FORWARD_ONLY        HttpConnectionManager_ForwardClientCertDetails = 1
	HttpConnectionManager_APPEND_FORWARD      HttpConnectionManager_ForwardClientCertDetails = 2
	HttpConnectionManager_SANITIZE_SET        HttpConnectionManager_ForwardClientCertDetails = 3
	HttpConnectionManager_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_6be8bc92cfb072ca, []int{0, 2}
}

type HttpConnectionManager_Tracing_OperationName int32

const (
	HttpConnectionManager_Tracing_INGRESS HttpConnectionManager_Tracing_OperationName = 0
	HttpConnectionManager_Tracing_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_6be8bc92cfb072ca, []int{0, 0, 0}
}

type HttpConnectionManager struct {
	CodecType  HttpConnectionManager_CodecType `protobuf:"varint,1,opt,name=codec_type,json=codecType,proto3,enum=envoy.config.filter.network.http_connection_manager.v3alpha.HttpConnectionManager_CodecType" json:"codec_type,omitempty"`
	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"`
	HttpFilters                                []*HttpFilter                                      `protobuf:"bytes,5,rep,name=http_filters,json=httpFilters,proto3" json:"http_filters,omitempty"`
	AddUserAgent                               *wrappers.BoolValue                                `protobuf:"bytes,6,opt,name=add_user_agent,json=addUserAgent,proto3" json:"add_user_agent,omitempty"`
	Tracing                                    *HttpConnectionManager_Tracing                     `protobuf:"bytes,7,opt,name=tracing,proto3" json:"tracing,omitempty"`
	CommonHttpProtocolOptions                  *core.HttpProtocolOptions                          `protobuf:"bytes,35,opt,name=common_http_protocol_options,json=commonHttpProtocolOptions,proto3" json:"common_http_protocol_options,omitempty"`
	HttpProtocolOptions                        *core.Http1ProtocolOptions                         `protobuf:"bytes,8,opt,name=http_protocol_options,json=httpProtocolOptions,proto3" json:"http_protocol_options,omitempty"`
	Http2ProtocolOptions                       *core.Http2ProtocolOptions                         `protobuf:"bytes,9,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	ServerName                                 string                                             `protobuf:"bytes,10,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	ServerHeaderTransformation                 HttpConnectionManager_ServerHeaderTransformation   `protobuf:"varint,34,opt,name=server_header_transformation,json=serverHeaderTransformation,proto3,enum=envoy.config.filter.network.http_connection_manager.v3alpha.HttpConnectionManager_ServerHeaderTransformation" json:"server_header_transformation,omitempty"`
	MaxRequestHeadersKb                        *wrappers.UInt32Value                              `protobuf:"bytes,29,opt,name=max_request_headers_kb,json=maxRequestHeadersKb,proto3" json:"max_request_headers_kb,omitempty"`
	StreamIdleTimeout                          *duration.Duration                                 `protobuf:"bytes,24,opt,name=stream_idle_timeout,json=streamIdleTimeout,proto3" json:"stream_idle_timeout,omitempty"`
	RequestTimeout                             *duration.Duration                                 `protobuf:"bytes,28,opt,name=request_timeout,json=requestTimeout,proto3" json:"request_timeout,omitempty"`
	DrainTimeout                               *duration.Duration                                 `protobuf:"bytes,12,opt,name=drain_timeout,json=drainTimeout,proto3" json:"drain_timeout,omitempty"`
	DelayedCloseTimeout                        *duration.Duration                                 `protobuf:"bytes,26,opt,name=delayed_close_timeout,json=delayedCloseTimeout,proto3" json:"delayed_close_timeout,omitempty"`
	AccessLog                                  []*v3alpha1.AccessLog                              `protobuf:"bytes,13,rep,name=access_log,json=accessLog,proto3" json:"access_log,omitempty"`
	UseRemoteAddress                           *wrappers.BoolValue                                `protobuf:"bytes,14,opt,name=use_remote_address,json=useRemoteAddress,proto3" json:"use_remote_address,omitempty"`
	XffNumTrustedHops                          uint32                                             `protobuf:"varint,19,opt,name=xff_num_trusted_hops,json=xffNumTrustedHops,proto3" json:"xff_num_trusted_hops,omitempty"`
	InternalAddressConfig                      *HttpConnectionManager_InternalAddressConfig       `protobuf:"bytes,25,opt,name=internal_address_config,json=internalAddressConfig,proto3" json:"internal_address_config,omitempty"`
	SkipXffAppend                              bool                                               `protobuf:"varint,21,opt,name=skip_xff_append,json=skipXffAppend,proto3" json:"skip_xff_append,omitempty"`
	Via                                        string                                             `protobuf:"bytes,22,opt,name=via,proto3" json:"via,omitempty"`
	GenerateRequestId                          *wrappers.BoolValue                                `protobuf:"bytes,15,opt,name=generate_request_id,json=generateRequestId,proto3" json:"generate_request_id,omitempty"`
	PreserveExternalRequestId                  bool                                               `protobuf:"varint,32,opt,name=preserve_external_request_id,json=preserveExternalRequestId,proto3" json:"preserve_external_request_id,omitempty"`
	ForwardClientCertDetails                   HttpConnectionManager_ForwardClientCertDetails     `protobuf:"varint,16,opt,name=forward_client_cert_details,json=forwardClientCertDetails,proto3,enum=envoy.config.filter.network.http_connection_manager.v3alpha.HttpConnectionManager_ForwardClientCertDetails" json:"forward_client_cert_details,omitempty"`
	SetCurrentClientCertDetails                *HttpConnectionManager_SetCurrentClientCertDetails `protobuf:"bytes,17,opt,name=set_current_client_cert_details,json=setCurrentClientCertDetails,proto3" json:"set_current_client_cert_details,omitempty"`
	Proxy_100Continue                          bool                                               `protobuf:"varint,18,opt,name=proxy_100_continue,json=proxy100Continue,proto3" json:"proxy_100_continue,omitempty"`
	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"`
	NormalizePath                              *wrappers.BoolValue                                `protobuf:"bytes,30,opt,name=normalize_path,json=normalizePath,proto3" json:"normalize_path,omitempty"`
	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_6be8bc92cfb072ca, []int{0}
}

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

var xxx_messageInfo_HttpConnectionManager proto.InternalMessageInfo

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

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

type isHttpConnectionManager_RouteSpecifier interface {
	isHttpConnectionManager_RouteSpecifier()
}

type HttpConnectionManager_Rds struct {
	Rds *Rds `protobuf:"bytes,3,opt,name=rds,proto3,oneof"`
}

type HttpConnectionManager_RouteConfig struct {
	RouteConfig *v3alpha.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) GetRds() *Rds {
	if x, ok := m.GetRouteSpecifier().(*HttpConnectionManager_Rds); ok {
		return x.Rds
	}
	return nil
}

func (m *HttpConnectionManager) GetRouteConfig() *v3alpha.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() *wrappers.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) GetCommonHttpProtocolOptions() *core.HttpProtocolOptions {
	if m != nil {
		return m.CommonHttpProtocolOptions
	}
	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) GetServerHeaderTransformation() HttpConnectionManager_ServerHeaderTransformation {
	if m != nil {
		return m.ServerHeaderTransformation
	}
	return HttpConnectionManager_OVERWRITE
}

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

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

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

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

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

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

func (m *HttpConnectionManager) GetUseRemoteAddress() *wrappers.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() *wrappers.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 HttpConnectionManager_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() *wrappers.BoolValue {
	if m != nil {
		return m.NormalizePath
	}
	return nil
}

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*HttpConnectionManager) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*HttpConnectionManager_Rds)(nil),
		(*HttpConnectionManager_RouteConfig)(nil),
		(*HttpConnectionManager_ScopedRoutes)(nil),
	}
}

type HttpConnectionManager_Tracing struct {
	RequestHeadersForTags []string              `protobuf:"bytes,2,rep,name=request_headers_for_tags,json=requestHeadersForTags,proto3" json:"request_headers_for_tags,omitempty"`
	ClientSampling        *v3alpha2.Percent     `protobuf:"bytes,3,opt,name=client_sampling,json=clientSampling,proto3" json:"client_sampling,omitempty"`
	RandomSampling        *v3alpha2.Percent     `protobuf:"bytes,4,opt,name=random_sampling,json=randomSampling,proto3" json:"random_sampling,omitempty"`
	OverallSampling       *v3alpha2.Percent     `protobuf:"bytes,5,opt,name=overall_sampling,json=overallSampling,proto3" json:"overall_sampling,omitempty"`
	Verbose               bool                  `protobuf:"varint,6,opt,name=verbose,proto3" json:"verbose,omitempty"`
	MaxPathTagLength      *wrappers.UInt32Value `protobuf:"bytes,7,opt,name=max_path_tag_length,json=maxPathTagLength,proto3" json:"max_path_tag_length,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_6be8bc92cfb072ca, []int{0, 0}
}

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

var xxx_messageInfo_HttpConnectionManager_Tracing proto.InternalMessageInfo

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

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

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

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

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

func (m *HttpConnectionManager_Tracing) GetMaxPathTagLength() *wrappers.UInt32Value {
	if m != nil {
		return m.MaxPathTagLength
	}
	return nil
}

type HttpConnectionManager_InternalAddressConfig struct {
	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_6be8bc92cfb072ca, []int{0, 1}
}

func (m *HttpConnectionManager_InternalAddressConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HttpConnectionManager_InternalAddressConfig.Unmarshal(m, b)
}
func (m *HttpConnectionManager_InternalAddressConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HttpConnectionManager_InternalAddressConfig.Marshal(b, m, deterministic)
}
func (m *HttpConnectionManager_InternalAddressConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HttpConnectionManager_InternalAddressConfig.Merge(m, src)
}
func (m *HttpConnectionManager_InternalAddressConfig) XXX_Size() int {
	return xxx_messageInfo_HttpConnectionManager_InternalAddressConfig.Size(m)
}
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
}

type HttpConnectionManager_SetCurrentClientCertDetails struct {
	Subject              *wrappers.BoolValue `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
	Cert                 bool                `protobuf:"varint,3,opt,name=cert,proto3" json:"cert,omitempty"`
	Chain                bool                `protobuf:"varint,6,opt,name=chain,proto3" json:"chain,omitempty"`
	Dns                  bool                `protobuf:"varint,4,opt,name=dns,proto3" json:"dns,omitempty"`
	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_6be8bc92cfb072ca, []int{0, 2}
}

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

var xxx_messageInfo_HttpConnectionManager_SetCurrentClientCertDetails proto.InternalMessageInfo

func (m *HttpConnectionManager_SetCurrentClientCertDetails) GetSubject() *wrappers.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
}

type HttpConnectionManager_UpgradeConfig struct {
	UpgradeType          string              `protobuf:"bytes,1,opt,name=upgrade_type,json=upgradeType,proto3" json:"upgrade_type,omitempty"`
	Filters              []*HttpFilter       `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"`
	Enabled              *wrappers.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_6be8bc92cfb072ca, []int{0, 3}
}

func (m *HttpConnectionManager_UpgradeConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HttpConnectionManager_UpgradeConfig.Unmarshal(m, b)
}
func (m *HttpConnectionManager_UpgradeConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HttpConnectionManager_UpgradeConfig.Marshal(b, m, deterministic)
}
func (m *HttpConnectionManager_UpgradeConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HttpConnectionManager_UpgradeConfig.Merge(m, src)
}
func (m *HttpConnectionManager_UpgradeConfig) XXX_Size() int {
	return xxx_messageInfo_HttpConnectionManager_UpgradeConfig.Size(m)
}
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() *wrappers.BoolValue {
	if m != nil {
		return m.Enabled
	}
	return nil
}

type Rds struct {
	ConfigSource         *core.ConfigSource `protobuf:"bytes,1,opt,name=config_source,json=configSource,proto3" json:"config_source,omitempty"`
	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_6be8bc92cfb072ca, []int{1}
}

func (m *Rds) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Rds.Unmarshal(m, b)
}
func (m *Rds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Rds.Marshal(b, m, deterministic)
}
func (m *Rds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Rds.Merge(m, src)
}
func (m *Rds) XXX_Size() int {
	return xxx_messageInfo_Rds.Size(m)
}
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 ""
}

type ScopedRouteConfigurationsList struct {
	ScopedRouteConfigurations []*v3alpha.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_6be8bc92cfb072ca, []int{2}
}

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

var xxx_messageInfo_ScopedRouteConfigurationsList proto.InternalMessageInfo

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

type ScopedRoutes struct {
	Name            string                        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ScopeKeyBuilder *ScopedRoutes_ScopeKeyBuilder `protobuf:"bytes,2,opt,name=scope_key_builder,json=scopeKeyBuilder,proto3" json:"scope_key_builder,omitempty"`
	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_6be8bc92cfb072ca, []int{3}
}

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

var xxx_messageInfo_ScopedRoutes proto.InternalMessageInfo

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
}

type isScopedRoutes_ConfigSpecifier interface {
	isScopedRoutes_ConfigSpecifier()
}

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) 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_OneofWrappers is for the internal use of the proto package.
func (*ScopedRoutes) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ScopedRoutes_ScopedRouteConfigurationsList)(nil),
		(*ScopedRoutes_ScopedRds)(nil),
	}
}

type ScopedRoutes_ScopeKeyBuilder struct {
	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_6be8bc92cfb072ca, []int{3, 0}
}

func (m *ScopedRoutes_ScopeKeyBuilder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder.Unmarshal(m, b)
}
func (m *ScopedRoutes_ScopeKeyBuilder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder.Marshal(b, m, deterministic)
}
func (m *ScopedRoutes_ScopeKeyBuilder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder.Merge(m, src)
}
func (m *ScopedRoutes_ScopeKeyBuilder) XXX_Size() int {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder.Size(m)
}
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
}

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_6be8bc92cfb072ca, []int{3, 0, 0}
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder.Unmarshal(m, b)
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder.Marshal(b, m, deterministic)
}
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 xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder.Size(m)
}
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()
}

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_OneofWrappers is for the internal use of the proto package.
func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_)(nil),
	}
}

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor struct {
	Name             string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	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_6be8bc92cfb072ca, []int{3, 0, 0, 0}
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor.Unmarshal(m, b)
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor.Marshal(b, m, deterministic)
}
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 xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor.Size(m)
}
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

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 ""
}

type isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType interface {
	isScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_ExtractType()
}

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) 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_OneofWrappers is for the internal use of the proto package.
func (*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Index)(nil),
		(*ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_Element)(nil),
	}
}

type ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement struct {
	Separator            string   `protobuf:"bytes,1,opt,name=separator,proto3" json:"separator,omitempty"`
	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_6be8bc92cfb072ca, []int{3, 0, 0, 0, 0}
}

func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement.Unmarshal(m, b)
}
func (m *ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement.Marshal(b, m, deterministic)
}
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 xxx_messageInfo_ScopedRoutes_ScopeKeyBuilder_FragmentBuilder_HeaderValueExtractor_KvElement.Size(m)
}
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 {
	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_6be8bc92cfb072ca, []int{4}
}

func (m *ScopedRds) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScopedRds.Unmarshal(m, b)
}
func (m *ScopedRds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScopedRds.Marshal(b, m, deterministic)
}
func (m *ScopedRds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScopedRds.Merge(m, src)
}
func (m *ScopedRds) XXX_Size() int {
	return xxx_messageInfo_ScopedRds.Size(m)
}
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 {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to ConfigType:
	//	*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_6be8bc92cfb072ca, []int{5}
}

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

var xxx_messageInfo_HttpFilter proto.InternalMessageInfo

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

type isHttpFilter_ConfigType interface {
	isHttpFilter_ConfigType()
}

type HttpFilter_TypedConfig struct {
	TypedConfig *any.Any `protobuf:"bytes,4,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

func (*HttpFilter_TypedConfig) isHttpFilter_ConfigType() {}

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

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

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

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

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

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