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

package v2

import (
	fmt "fmt"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v2/core"
	route "github.com/envoyproxy/go-control-plane/envoy/api/v2/route"
	_type "github.com/envoyproxy/go-control-plane/envoy/type"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type ComparisonFilter_Op int32

const (
	// =
	ComparisonFilter_EQ ComparisonFilter_Op = 0
	// >=
	ComparisonFilter_GE ComparisonFilter_Op = 1
	// <=
	ComparisonFilter_LE ComparisonFilter_Op = 2
)

var ComparisonFilter_Op_name = map[int32]string{
	0: "EQ",
	1: "GE",
	2: "LE",
}

var ComparisonFilter_Op_value = map[string]int32{
	"EQ": 0,
	"GE": 1,
	"LE": 2,
}

func (x ComparisonFilter_Op) String() string {
	return proto.EnumName(ComparisonFilter_Op_name, int32(x))
}

func (ComparisonFilter_Op) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_67bfd82f8b509e9f, []int{2, 0}
}

type GrpcStatusFilter_Status int32

const (
	GrpcStatusFilter_OK                  GrpcStatusFilter_Status = 0
	GrpcStatusFilter_CANCELED            GrpcStatusFilter_Status = 1
	GrpcStatusFilter_UNKNOWN             GrpcStatusFilter_Status = 2
	GrpcStatusFilter_INVALID_ARGUMENT    GrpcStatusFilter_Status = 3
	GrpcStatusFilter_DEADLINE_EXCEEDED   GrpcStatusFilter_Status = 4
	GrpcStatusFilter_NOT_FOUND           GrpcStatusFilter_Status = 5
	GrpcStatusFilter_ALREADY_EXISTS      GrpcStatusFilter_Status = 6
	GrpcStatusFilter_PERMISSION_DENIED   GrpcStatusFilter_Status = 7
	GrpcStatusFilter_RESOURCE_EXHAUSTED  GrpcStatusFilter_Status = 8
	GrpcStatusFilter_FAILED_PRECONDITION GrpcStatusFilter_Status = 9
	GrpcStatusFilter_ABORTED             GrpcStatusFilter_Status = 10
	GrpcStatusFilter_OUT_OF_RANGE        GrpcStatusFilter_Status = 11
	GrpcStatusFilter_UNIMPLEMENTED       GrpcStatusFilter_Status = 12
	GrpcStatusFilter_INTERNAL            GrpcStatusFilter_Status = 13
	GrpcStatusFilter_UNAVAILABLE         GrpcStatusFilter_Status = 14
	GrpcStatusFilter_DATA_LOSS           GrpcStatusFilter_Status = 15
	GrpcStatusFilter_UNAUTHENTICATED     GrpcStatusFilter_Status = 16
)

var GrpcStatusFilter_Status_name = map[int32]string{
	0:  "OK",
	1:  "CANCELED",
	2:  "UNKNOWN",
	3:  "INVALID_ARGUMENT",
	4:  "DEADLINE_EXCEEDED",
	5:  "NOT_FOUND",
	6:  "ALREADY_EXISTS",
	7:  "PERMISSION_DENIED",
	8:  "RESOURCE_EXHAUSTED",
	9:  "FAILED_PRECONDITION",
	10: "ABORTED",
	11: "OUT_OF_RANGE",
	12: "UNIMPLEMENTED",
	13: "INTERNAL",
	14: "UNAVAILABLE",
	15: "DATA_LOSS",
	16: "UNAUTHENTICATED",
}

var GrpcStatusFilter_Status_value = map[string]int32{
	"OK":                  0,
	"CANCELED":            1,
	"UNKNOWN":             2,
	"INVALID_ARGUMENT":    3,
	"DEADLINE_EXCEEDED":   4,
	"NOT_FOUND":           5,
	"ALREADY_EXISTS":      6,
	"PERMISSION_DENIED":   7,
	"RESOURCE_EXHAUSTED":  8,
	"FAILED_PRECONDITION": 9,
	"ABORTED":             10,
	"OUT_OF_RANGE":        11,
	"UNIMPLEMENTED":       12,
	"INTERNAL":            13,
	"UNAVAILABLE":         14,
	"DATA_LOSS":           15,
	"UNAUTHENTICATED":     16,
}

func (x GrpcStatusFilter_Status) String() string {
	return proto.EnumName(GrpcStatusFilter_Status_name, int32(x))
}

func (GrpcStatusFilter_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_67bfd82f8b509e9f, []int{12, 0}
}

type AccessLog struct {
	// The name of the access log implementation to instantiate. The name must
	// match a statically registered access log. Current built-in loggers include:
	//
	// #. "envoy.file_access_log"
	// #. "envoy.http_grpc_access_log"
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Filter which is used to determine if the access log needs to be written.
	Filter *AccessLogFilter `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
	// Custom configuration that depends on the access log being instantiated. Built-in
	// configurations include:
	//
	// #. "envoy.file_access_log": :ref:`FileAccessLog
	//    <envoy_api_msg_config.accesslog.v2.FileAccessLog>`
	// #. "envoy.http_grpc_access_log": :ref:`HttpGrpcAccessLogConfig
	//    <envoy_api_msg_config.accesslog.v2.HttpGrpcAccessLogConfig>`
	//
	// Types that are valid to be assigned to ConfigType:
	//	*AccessLog_Config
	//	*AccessLog_TypedConfig
	ConfigType           isAccessLog_ConfigType `protobuf_oneof:"config_type"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_AccessLog proto.InternalMessageInfo

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

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

func (*AccessLog_Config) isAccessLog_ConfigType()      {}
func (*AccessLog_TypedConfig) isAccessLog_ConfigType() {}

func (m *AccessLog) GetConfigType() isAccessLog_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

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

func (m *AccessLog) GetFilter() *AccessLogFilter {
	if m != nil {
		return m.Filter
	}
	return nil
}

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*AccessLog) 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 _AccessLog_OneofMarshaler, _AccessLog_OneofUnmarshaler, _AccessLog_OneofSizer, []interface{}{
		(*AccessLog_Config)(nil),
		(*AccessLog_TypedConfig)(nil),
	}
}

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

func _AccessLog_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*AccessLog)
	switch tag {
	case 3: // config_type.config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.Struct)
		err := b.DecodeMessage(msg)
		m.ConfigType = &AccessLog_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 = &AccessLog_TypedConfig{msg}
		return true, err
	default:
		return false, nil
	}
}

func _AccessLog_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*AccessLog)
	// config_type
	switch x := m.ConfigType.(type) {
	case *AccessLog_Config:
		s := proto.Size(x.Config)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLog_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
}

type AccessLogFilter struct {
	// Types that are valid to be assigned to FilterSpecifier:
	//	*AccessLogFilter_StatusCodeFilter
	//	*AccessLogFilter_DurationFilter
	//	*AccessLogFilter_NotHealthCheckFilter
	//	*AccessLogFilter_TraceableFilter
	//	*AccessLogFilter_RuntimeFilter
	//	*AccessLogFilter_AndFilter
	//	*AccessLogFilter_OrFilter
	//	*AccessLogFilter_HeaderFilter
	//	*AccessLogFilter_ResponseFlagFilter
	//	*AccessLogFilter_GrpcStatusFilter
	//	*AccessLogFilter_ExtensionFilter
	FilterSpecifier      isAccessLogFilter_FilterSpecifier `protobuf_oneof:"filter_specifier"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

var xxx_messageInfo_AccessLogFilter proto.InternalMessageInfo

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

type AccessLogFilter_StatusCodeFilter struct {
	StatusCodeFilter *StatusCodeFilter `protobuf:"bytes,1,opt,name=status_code_filter,json=statusCodeFilter,proto3,oneof"`
}
type AccessLogFilter_DurationFilter struct {
	DurationFilter *DurationFilter `protobuf:"bytes,2,opt,name=duration_filter,json=durationFilter,proto3,oneof"`
}
type AccessLogFilter_NotHealthCheckFilter struct {
	NotHealthCheckFilter *NotHealthCheckFilter `protobuf:"bytes,3,opt,name=not_health_check_filter,json=notHealthCheckFilter,proto3,oneof"`
}
type AccessLogFilter_TraceableFilter struct {
	TraceableFilter *TraceableFilter `protobuf:"bytes,4,opt,name=traceable_filter,json=traceableFilter,proto3,oneof"`
}
type AccessLogFilter_RuntimeFilter struct {
	RuntimeFilter *RuntimeFilter `protobuf:"bytes,5,opt,name=runtime_filter,json=runtimeFilter,proto3,oneof"`
}
type AccessLogFilter_AndFilter struct {
	AndFilter *AndFilter `protobuf:"bytes,6,opt,name=and_filter,json=andFilter,proto3,oneof"`
}
type AccessLogFilter_OrFilter struct {
	OrFilter *OrFilter `protobuf:"bytes,7,opt,name=or_filter,json=orFilter,proto3,oneof"`
}
type AccessLogFilter_HeaderFilter struct {
	HeaderFilter *HeaderFilter `protobuf:"bytes,8,opt,name=header_filter,json=headerFilter,proto3,oneof"`
}
type AccessLogFilter_ResponseFlagFilter struct {
	ResponseFlagFilter *ResponseFlagFilter `protobuf:"bytes,9,opt,name=response_flag_filter,json=responseFlagFilter,proto3,oneof"`
}
type AccessLogFilter_GrpcStatusFilter struct {
	GrpcStatusFilter *GrpcStatusFilter `protobuf:"bytes,10,opt,name=grpc_status_filter,json=grpcStatusFilter,proto3,oneof"`
}
type AccessLogFilter_ExtensionFilter struct {
	ExtensionFilter *ExtensionFilter `protobuf:"bytes,11,opt,name=extension_filter,json=extensionFilter,proto3,oneof"`
}

func (*AccessLogFilter_StatusCodeFilter) isAccessLogFilter_FilterSpecifier()     {}
func (*AccessLogFilter_DurationFilter) isAccessLogFilter_FilterSpecifier()       {}
func (*AccessLogFilter_NotHealthCheckFilter) isAccessLogFilter_FilterSpecifier() {}
func (*AccessLogFilter_TraceableFilter) isAccessLogFilter_FilterSpecifier()      {}
func (*AccessLogFilter_RuntimeFilter) isAccessLogFilter_FilterSpecifier()        {}
func (*AccessLogFilter_AndFilter) isAccessLogFilter_FilterSpecifier()            {}
func (*AccessLogFilter_OrFilter) isAccessLogFilter_FilterSpecifier()             {}
func (*AccessLogFilter_HeaderFilter) isAccessLogFilter_FilterSpecifier()         {}
func (*AccessLogFilter_ResponseFlagFilter) isAccessLogFilter_FilterSpecifier()   {}
func (*AccessLogFilter_GrpcStatusFilter) isAccessLogFilter_FilterSpecifier()     {}
func (*AccessLogFilter_ExtensionFilter) isAccessLogFilter_FilterSpecifier()      {}

func (m *AccessLogFilter) GetFilterSpecifier() isAccessLogFilter_FilterSpecifier {
	if m != nil {
		return m.FilterSpecifier
	}
	return nil
}

func (m *AccessLogFilter) GetStatusCodeFilter() *StatusCodeFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_StatusCodeFilter); ok {
		return x.StatusCodeFilter
	}
	return nil
}

func (m *AccessLogFilter) GetDurationFilter() *DurationFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_DurationFilter); ok {
		return x.DurationFilter
	}
	return nil
}

func (m *AccessLogFilter) GetNotHealthCheckFilter() *NotHealthCheckFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_NotHealthCheckFilter); ok {
		return x.NotHealthCheckFilter
	}
	return nil
}

func (m *AccessLogFilter) GetTraceableFilter() *TraceableFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_TraceableFilter); ok {
		return x.TraceableFilter
	}
	return nil
}

func (m *AccessLogFilter) GetRuntimeFilter() *RuntimeFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_RuntimeFilter); ok {
		return x.RuntimeFilter
	}
	return nil
}

func (m *AccessLogFilter) GetAndFilter() *AndFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_AndFilter); ok {
		return x.AndFilter
	}
	return nil
}

func (m *AccessLogFilter) GetOrFilter() *OrFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_OrFilter); ok {
		return x.OrFilter
	}
	return nil
}

func (m *AccessLogFilter) GetHeaderFilter() *HeaderFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_HeaderFilter); ok {
		return x.HeaderFilter
	}
	return nil
}

func (m *AccessLogFilter) GetResponseFlagFilter() *ResponseFlagFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_ResponseFlagFilter); ok {
		return x.ResponseFlagFilter
	}
	return nil
}

func (m *AccessLogFilter) GetGrpcStatusFilter() *GrpcStatusFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_GrpcStatusFilter); ok {
		return x.GrpcStatusFilter
	}
	return nil
}

func (m *AccessLogFilter) GetExtensionFilter() *ExtensionFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_ExtensionFilter); ok {
		return x.ExtensionFilter
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*AccessLogFilter) 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 _AccessLogFilter_OneofMarshaler, _AccessLogFilter_OneofUnmarshaler, _AccessLogFilter_OneofSizer, []interface{}{
		(*AccessLogFilter_StatusCodeFilter)(nil),
		(*AccessLogFilter_DurationFilter)(nil),
		(*AccessLogFilter_NotHealthCheckFilter)(nil),
		(*AccessLogFilter_TraceableFilter)(nil),
		(*AccessLogFilter_RuntimeFilter)(nil),
		(*AccessLogFilter_AndFilter)(nil),
		(*AccessLogFilter_OrFilter)(nil),
		(*AccessLogFilter_HeaderFilter)(nil),
		(*AccessLogFilter_ResponseFlagFilter)(nil),
		(*AccessLogFilter_GrpcStatusFilter)(nil),
		(*AccessLogFilter_ExtensionFilter)(nil),
	}
}

func _AccessLogFilter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*AccessLogFilter)
	// filter_specifier
	switch x := m.FilterSpecifier.(type) {
	case *AccessLogFilter_StatusCodeFilter:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StatusCodeFilter); err != nil {
			return err
		}
	case *AccessLogFilter_DurationFilter:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DurationFilter); err != nil {
			return err
		}
	case *AccessLogFilter_NotHealthCheckFilter:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NotHealthCheckFilter); err != nil {
			return err
		}
	case *AccessLogFilter_TraceableFilter:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TraceableFilter); err != nil {
			return err
		}
	case *AccessLogFilter_RuntimeFilter:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RuntimeFilter); err != nil {
			return err
		}
	case *AccessLogFilter_AndFilter:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AndFilter); err != nil {
			return err
		}
	case *AccessLogFilter_OrFilter:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.OrFilter); err != nil {
			return err
		}
	case *AccessLogFilter_HeaderFilter:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.HeaderFilter); err != nil {
			return err
		}
	case *AccessLogFilter_ResponseFlagFilter:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResponseFlagFilter); err != nil {
			return err
		}
	case *AccessLogFilter_GrpcStatusFilter:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GrpcStatusFilter); err != nil {
			return err
		}
	case *AccessLogFilter_ExtensionFilter:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ExtensionFilter); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("AccessLogFilter.FilterSpecifier has unexpected type %T", x)
	}
	return nil
}

func _AccessLogFilter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*AccessLogFilter)
	switch tag {
	case 1: // filter_specifier.status_code_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StatusCodeFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_StatusCodeFilter{msg}
		return true, err
	case 2: // filter_specifier.duration_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DurationFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_DurationFilter{msg}
		return true, err
	case 3: // filter_specifier.not_health_check_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NotHealthCheckFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_NotHealthCheckFilter{msg}
		return true, err
	case 4: // filter_specifier.traceable_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TraceableFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_TraceableFilter{msg}
		return true, err
	case 5: // filter_specifier.runtime_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RuntimeFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_RuntimeFilter{msg}
		return true, err
	case 6: // filter_specifier.and_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(AndFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_AndFilter{msg}
		return true, err
	case 7: // filter_specifier.or_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(OrFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_OrFilter{msg}
		return true, err
	case 8: // filter_specifier.header_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(HeaderFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_HeaderFilter{msg}
		return true, err
	case 9: // filter_specifier.response_flag_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResponseFlagFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_ResponseFlagFilter{msg}
		return true, err
	case 10: // filter_specifier.grpc_status_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GrpcStatusFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_GrpcStatusFilter{msg}
		return true, err
	case 11: // filter_specifier.extension_filter
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ExtensionFilter)
		err := b.DecodeMessage(msg)
		m.FilterSpecifier = &AccessLogFilter_ExtensionFilter{msg}
		return true, err
	default:
		return false, nil
	}
}

func _AccessLogFilter_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*AccessLogFilter)
	// filter_specifier
	switch x := m.FilterSpecifier.(type) {
	case *AccessLogFilter_StatusCodeFilter:
		s := proto.Size(x.StatusCodeFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_DurationFilter:
		s := proto.Size(x.DurationFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_NotHealthCheckFilter:
		s := proto.Size(x.NotHealthCheckFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_TraceableFilter:
		s := proto.Size(x.TraceableFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_RuntimeFilter:
		s := proto.Size(x.RuntimeFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_AndFilter:
		s := proto.Size(x.AndFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_OrFilter:
		s := proto.Size(x.OrFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_HeaderFilter:
		s := proto.Size(x.HeaderFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_ResponseFlagFilter:
		s := proto.Size(x.ResponseFlagFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_GrpcStatusFilter:
		s := proto.Size(x.GrpcStatusFilter)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessLogFilter_ExtensionFilter:
		s := proto.Size(x.ExtensionFilter)
		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
}

// Filter on an integer comparison.
type ComparisonFilter struct {
	// Comparison operator.
	Op ComparisonFilter_Op `protobuf:"varint,1,opt,name=op,proto3,enum=envoy.config.filter.accesslog.v2.ComparisonFilter_Op" json:"op,omitempty"`
	// Value to compare against.
	Value                *core.RuntimeUInt32 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_ComparisonFilter proto.InternalMessageInfo

func (m *ComparisonFilter) GetOp() ComparisonFilter_Op {
	if m != nil {
		return m.Op
	}
	return ComparisonFilter_EQ
}

func (m *ComparisonFilter) GetValue() *core.RuntimeUInt32 {
	if m != nil {
		return m.Value
	}
	return nil
}

// Filters on HTTP response/status code.
type StatusCodeFilter struct {
	// Comparison.
	Comparison           *ComparisonFilter `protobuf:"bytes,1,opt,name=comparison,proto3" json:"comparison,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_StatusCodeFilter proto.InternalMessageInfo

func (m *StatusCodeFilter) GetComparison() *ComparisonFilter {
	if m != nil {
		return m.Comparison
	}
	return nil
}

// Filters on total request duration in milliseconds.
type DurationFilter struct {
	// Comparison.
	Comparison           *ComparisonFilter `protobuf:"bytes,1,opt,name=comparison,proto3" json:"comparison,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_DurationFilter proto.InternalMessageInfo

func (m *DurationFilter) GetComparison() *ComparisonFilter {
	if m != nil {
		return m.Comparison
	}
	return nil
}

// Filters for requests that are not health check requests. A health check
// request is marked by the health check filter.
type NotHealthCheckFilter struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NotHealthCheckFilter proto.InternalMessageInfo

// Filters for requests that are traceable. See the tracing overview for more
// information on how a request becomes traceable.
type TraceableFilter struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TraceableFilter proto.InternalMessageInfo

// Filters for random sampling of requests.
type RuntimeFilter struct {
	// Runtime key to get an optional overridden numerator for use in the *percent_sampled* field.
	// If found in runtime, this value will replace the default numerator.
	RuntimeKey string `protobuf:"bytes,1,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	// The default sampling percentage. If not specified, defaults to 0% with denominator of 100.
	PercentSampled *_type.FractionalPercent `protobuf:"bytes,2,opt,name=percent_sampled,json=percentSampled,proto3" json:"percent_sampled,omitempty"`
	// By default, sampling pivots on the header
	// :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` being present. If
	// :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` is present, the filter will
	// consistently sample across multiple hosts based on the runtime key value and the value
	// extracted from :ref:`x-request-id<config_http_conn_man_headers_x-request-id>`. If it is
	// missing, or *use_independent_randomness* is set to true, the filter will randomly sample based
	// on the runtime key value alone. *use_independent_randomness* can be used for logging kill
	// switches within complex nested :ref:`AndFilter
	// <envoy_api_msg_config.filter.accesslog.v2.AndFilter>` and :ref:`OrFilter
	// <envoy_api_msg_config.filter.accesslog.v2.OrFilter>` blocks that are easier to reason about
	// from a probability perspective (i.e., setting to true will cause the filter to behave like
	// an independent random variable when composed within logical operator filters).
	UseIndependentRandomness bool     `protobuf:"varint,3,opt,name=use_independent_randomness,json=useIndependentRandomness,proto3" json:"use_independent_randomness,omitempty"`
	XXX_NoUnkeyedLiteral     struct{} `json:"-"`
	XXX_unrecognized         []byte   `json:"-"`
	XXX_sizecache            int32    `json:"-"`
}

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

var xxx_messageInfo_RuntimeFilter proto.InternalMessageInfo

func (m *RuntimeFilter) GetRuntimeKey() string {
	if m != nil {
		return m.RuntimeKey
	}
	return ""
}

func (m *RuntimeFilter) GetPercentSampled() *_type.FractionalPercent {
	if m != nil {
		return m.PercentSampled
	}
	return nil
}

func (m *RuntimeFilter) GetUseIndependentRandomness() bool {
	if m != nil {
		return m.UseIndependentRandomness
	}
	return false
}

// Performs a logical “and” operation on the result of each filter in filters.
// Filters are evaluated sequentially and if one of them returns false, the
// filter returns false immediately.
type AndFilter struct {
	Filters              []*AccessLogFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_AndFilter proto.InternalMessageInfo

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

// Performs a logical “or” operation on the result of each individual filter.
// Filters are evaluated sequentially and if one of them returns true, the
// filter returns true immediately.
type OrFilter struct {
	Filters              []*AccessLogFilter `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_OrFilter proto.InternalMessageInfo

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

// Filters requests based on the presence or value of a request header.
type HeaderFilter struct {
	// Only requests with a header which matches the specified HeaderMatcher will pass the filter
	// check.
	Header               *route.HeaderMatcher `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_HeaderFilter proto.InternalMessageInfo

func (m *HeaderFilter) GetHeader() *route.HeaderMatcher {
	if m != nil {
		return m.Header
	}
	return nil
}

// Filters requests that received responses with an Envoy response flag set.
// A list of the response flags can be found
// in the access log formatter :ref:`documentation<config_access_log_format_response_flags>`.
type ResponseFlagFilter struct {
	// Only responses with the any of the flags listed in this field will be logged.
	// This field is optional. If it is not specified, then any response flag will pass
	// the filter check.
	Flags                []string `protobuf:"bytes,1,rep,name=flags,proto3" json:"flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ResponseFlagFilter proto.InternalMessageInfo

func (m *ResponseFlagFilter) GetFlags() []string {
	if m != nil {
		return m.Flags
	}
	return nil
}

// Filters gRPC requests based on their response status. If a gRPC status is not provided, the
// filter will infer the status from the HTTP status code.
type GrpcStatusFilter struct {
	// Logs only responses that have any one of the gRPC statuses in this field.
	Statuses []GrpcStatusFilter_Status `protobuf:"varint,1,rep,packed,name=statuses,proto3,enum=envoy.config.filter.accesslog.v2.GrpcStatusFilter_Status" json:"statuses,omitempty"`
	// If included and set to true, the filter will instead block all responses with a gRPC status or
	// inferred gRPC status enumerated in statuses, and allow all other responses.
	Exclude              bool     `protobuf:"varint,2,opt,name=exclude,proto3" json:"exclude,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GrpcStatusFilter proto.InternalMessageInfo

func (m *GrpcStatusFilter) GetStatuses() []GrpcStatusFilter_Status {
	if m != nil {
		return m.Statuses
	}
	return nil
}

func (m *GrpcStatusFilter) GetExclude() bool {
	if m != nil {
		return m.Exclude
	}
	return false
}

// Extension filter is statically registered at runtime.
type ExtensionFilter struct {
	// The name of the filter implementation to instantiate. The name must
	// match a statically registered filter.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Custom configuration that depends on the filter being instantiated.
	//
	// Types that are valid to be assigned to ConfigType:
	//	*ExtensionFilter_Config
	//	*ExtensionFilter_TypedConfig
	ConfigType           isExtensionFilter_ConfigType `protobuf_oneof:"config_type"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_ExtensionFilter proto.InternalMessageInfo

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

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

func (*ExtensionFilter_Config) isExtensionFilter_ConfigType()      {}
func (*ExtensionFilter_TypedConfig) isExtensionFilter_ConfigType() {}

func (m *ExtensionFilter) GetConfigType() isExtensionFilter_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

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

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ExtensionFilter) 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 _ExtensionFilter_OneofMarshaler, _ExtensionFilter_OneofUnmarshaler, _ExtensionFilter_OneofSizer, []interface{}{
		(*ExtensionFilter_Config)(nil),
		(*ExtensionFilter_TypedConfig)(nil),
	}
}

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

func _ExtensionFilter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ExtensionFilter)
	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 = &ExtensionFilter_Config{msg}
		return true, err
	case 3: // config_type.typed_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.Any)
		err := b.DecodeMessage(msg)
		m.ConfigType = &ExtensionFilter_TypedConfig{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ExtensionFilter_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ExtensionFilter)
	// config_type
	switch x := m.ConfigType.(type) {
	case *ExtensionFilter_Config:
		s := proto.Size(x.Config)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ExtensionFilter_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.accesslog.v2.ComparisonFilter_Op", ComparisonFilter_Op_name, ComparisonFilter_Op_value)
	proto.RegisterEnum("envoy.config.filter.accesslog.v2.GrpcStatusFilter_Status", GrpcStatusFilter_Status_name, GrpcStatusFilter_Status_value)
	proto.RegisterType((*AccessLog)(nil), "envoy.config.filter.accesslog.v2.AccessLog")
	proto.RegisterType((*AccessLogFilter)(nil), "envoy.config.filter.accesslog.v2.AccessLogFilter")
	proto.RegisterType((*ComparisonFilter)(nil), "envoy.config.filter.accesslog.v2.ComparisonFilter")
	proto.RegisterType((*StatusCodeFilter)(nil), "envoy.config.filter.accesslog.v2.StatusCodeFilter")
	proto.RegisterType((*DurationFilter)(nil), "envoy.config.filter.accesslog.v2.DurationFilter")
	proto.RegisterType((*NotHealthCheckFilter)(nil), "envoy.config.filter.accesslog.v2.NotHealthCheckFilter")
	proto.RegisterType((*TraceableFilter)(nil), "envoy.config.filter.accesslog.v2.TraceableFilter")
	proto.RegisterType((*RuntimeFilter)(nil), "envoy.config.filter.accesslog.v2.RuntimeFilter")
	proto.RegisterType((*AndFilter)(nil), "envoy.config.filter.accesslog.v2.AndFilter")
	proto.RegisterType((*OrFilter)(nil), "envoy.config.filter.accesslog.v2.OrFilter")
	proto.RegisterType((*HeaderFilter)(nil), "envoy.config.filter.accesslog.v2.HeaderFilter")
	proto.RegisterType((*ResponseFlagFilter)(nil), "envoy.config.filter.accesslog.v2.ResponseFlagFilter")
	proto.RegisterType((*GrpcStatusFilter)(nil), "envoy.config.filter.accesslog.v2.GrpcStatusFilter")
	proto.RegisterType((*ExtensionFilter)(nil), "envoy.config.filter.accesslog.v2.ExtensionFilter")
}

func init() {
	proto.RegisterFile("envoy/config/filter/accesslog/v2/accesslog.proto", fileDescriptor_67bfd82f8b509e9f)
}

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

func (m *AccessLog) 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 *AccessLog) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Filter != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Filter.Size()))
		n1, err := m.Filter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.ConfigType != nil {
		nn2, err := m.ConfigType.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn2
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AccessLog_Config) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Config != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Config.Size()))
		n3, err := m.Config.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}
func (m *AccessLog_TypedConfig) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TypedConfig != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.TypedConfig.Size()))
		n4, err := m.TypedConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}
func (m *AccessLogFilter) 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 *AccessLogFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.FilterSpecifier != nil {
		nn5, err := m.FilterSpecifier.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn5
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AccessLogFilter_StatusCodeFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.StatusCodeFilter != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.StatusCodeFilter.Size()))
		n6, err := m.StatusCodeFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}
func (m *AccessLogFilter_DurationFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.DurationFilter != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.DurationFilter.Size()))
		n7, err := m.DurationFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}
func (m *AccessLogFilter_NotHealthCheckFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.NotHealthCheckFilter != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.NotHealthCheckFilter.Size()))
		n8, err := m.NotHealthCheckFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}
func (m *AccessLogFilter_TraceableFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TraceableFilter != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.TraceableFilter.Size()))
		n9, err := m.TraceableFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	return i, nil
}
func (m *AccessLogFilter_RuntimeFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RuntimeFilter != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.RuntimeFilter.Size()))
		n10, err := m.RuntimeFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}
func (m *AccessLogFilter_AndFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.AndFilter != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.AndFilter.Size()))
		n11, err := m.AndFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *AccessLogFilter_OrFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.OrFilter != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.OrFilter.Size()))
		n12, err := m.OrFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}
func (m *AccessLogFilter_HeaderFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HeaderFilter != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.HeaderFilter.Size()))
		n13, err := m.HeaderFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	return i, nil
}
func (m *AccessLogFilter_ResponseFlagFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ResponseFlagFilter != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.ResponseFlagFilter.Size()))
		n14, err := m.ResponseFlagFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	return i, nil
}
func (m *AccessLogFilter_GrpcStatusFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.GrpcStatusFilter != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.GrpcStatusFilter.Size()))
		n15, err := m.GrpcStatusFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}
func (m *AccessLogFilter_ExtensionFilter) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ExtensionFilter != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.ExtensionFilter.Size()))
		n16, err := m.ExtensionFilter.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}
func (m *ComparisonFilter) 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 *ComparisonFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Op != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Op))
	}
	if m.Value != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Value.Size()))
		n17, err := m.Value.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StatusCodeFilter) 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 *StatusCodeFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Comparison != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Comparison.Size()))
		n18, err := m.Comparison.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DurationFilter) 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 *DurationFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Comparison != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Comparison.Size()))
		n19, err := m.Comparison.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *NotHealthCheckFilter) 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 *NotHealthCheckFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TraceableFilter) 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 *TraceableFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *RuntimeFilter) 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 *RuntimeFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RuntimeKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(len(m.RuntimeKey)))
		i += copy(dAtA[i:], m.RuntimeKey)
	}
	if m.PercentSampled != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.PercentSampled.Size()))
		n20, err := m.PercentSampled.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if m.UseIndependentRandomness {
		dAtA[i] = 0x18
		i++
		if m.UseIndependentRandomness {
			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 *AndFilter) 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 *AndFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Filters) > 0 {
		for _, msg := range m.Filters {
			dAtA[i] = 0xa
			i++
			i = encodeVarintAccesslog(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 *OrFilter) 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 *OrFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Filters) > 0 {
		for _, msg := range m.Filters {
			dAtA[i] = 0x12
			i++
			i = encodeVarintAccesslog(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 *HeaderFilter) 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 *HeaderFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Header.Size()))
		n21, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ResponseFlagFilter) 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 *ResponseFlagFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Flags) > 0 {
		for _, s := range m.Flags {
			dAtA[i] = 0xa
			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.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GrpcStatusFilter) 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 *GrpcStatusFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Statuses) > 0 {
		dAtA23 := make([]byte, len(m.Statuses)*10)
		var j22 int
		for _, num := range m.Statuses {
			for num >= 1<<7 {
				dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j22++
			}
			dAtA23[j22] = uint8(num)
			j22++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(j22))
		i += copy(dAtA[i:], dAtA23[:j22])
	}
	if m.Exclude {
		dAtA[i] = 0x10
		i++
		if m.Exclude {
			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 *ExtensionFilter) 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 *ExtensionFilter) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ConfigType != nil {
		nn24, err := m.ConfigType.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn24
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ExtensionFilter_Config) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Config != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.Config.Size()))
		n25, err := m.Config.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	return i, nil
}
func (m *ExtensionFilter_TypedConfig) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TypedConfig != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintAccesslog(dAtA, i, uint64(m.TypedConfig.Size()))
		n26, err := m.TypedConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	return i, nil
}
func encodeVarintAccesslog(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 *AccessLog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAccesslog(uint64(l))
	}
	if m.Filter != nil {
		l = m.Filter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	if m.ConfigType != nil {
		n += m.ConfigType.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccessLog_Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLog_TypedConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TypedConfig != nil {
		l = m.TypedConfig.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FilterSpecifier != nil {
		n += m.FilterSpecifier.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccessLogFilter_StatusCodeFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StatusCodeFilter != nil {
		l = m.StatusCodeFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_DurationFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DurationFilter != nil {
		l = m.DurationFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_NotHealthCheckFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NotHealthCheckFilter != nil {
		l = m.NotHealthCheckFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_TraceableFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TraceableFilter != nil {
		l = m.TraceableFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_RuntimeFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RuntimeFilter != nil {
		l = m.RuntimeFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_AndFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AndFilter != nil {
		l = m.AndFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_OrFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrFilter != nil {
		l = m.OrFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_HeaderFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HeaderFilter != nil {
		l = m.HeaderFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_ResponseFlagFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResponseFlagFilter != nil {
		l = m.ResponseFlagFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_GrpcStatusFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GrpcStatusFilter != nil {
		l = m.GrpcStatusFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *AccessLogFilter_ExtensionFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExtensionFilter != nil {
		l = m.ExtensionFilter.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	return n
}
func (m *ComparisonFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovAccesslog(uint64(m.Op))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func (m *RuntimeFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RuntimeKey)
	if l > 0 {
		n += 1 + l + sovAccesslog(uint64(l))
	}
	if m.PercentSampled != nil {
		l = m.PercentSampled.Size()
		n += 1 + l + sovAccesslog(uint64(l))
	}
	if m.UseIndependentRandomness {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func (m *GrpcStatusFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Statuses) > 0 {
		l = 0
		for _, e := range m.Statuses {
			l += sovAccesslog(uint64(e))
		}
		n += 1 + sovAccesslog(uint64(l)) + l
	}
	if m.Exclude {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func sovAccesslog(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozAccesslog(x uint64) (n int) {
	return sovAccesslog(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *AccessLog) 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 ErrIntOverflowAccesslog
			}
			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: AccessLog: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccessLog: 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 ErrIntOverflowAccesslog
				}
				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 ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 Filter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Filter == nil {
				m.Filter = &AccessLogFilter{}
			}
			if err := m.Filter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Struct{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigType = &AccessLog_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 ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Any{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigType = &AccessLog_TypedConfig{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *AccessLogFilter) 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 ErrIntOverflowAccesslog
			}
			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: AccessLogFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccessLogFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusCodeFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &StatusCodeFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_StatusCodeFilter{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DurationFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DurationFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_DurationFilter{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotHealthCheckFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotHealthCheckFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_NotHealthCheckFilter{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceableFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TraceableFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_TraceableFilter{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RuntimeFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_RuntimeFilter{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AndFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AndFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_AndFilter{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OrFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_OrFilter{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HeaderFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_HeaderFilter{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResponseFlagFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ResponseFlagFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_ResponseFlagFilter{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GrpcStatusFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GrpcStatusFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_GrpcStatusFilter{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtensionFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ExtensionFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FilterSpecifier = &AccessLogFilter_ExtensionFilter{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *ComparisonFilter) 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 ErrIntOverflowAccesslog
			}
			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: ComparisonFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ComparisonFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= ComparisonFilter_Op(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &core.RuntimeUInt32{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *StatusCodeFilter) 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 ErrIntOverflowAccesslog
			}
			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: StatusCodeFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatusCodeFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Comparison", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Comparison == nil {
				m.Comparison = &ComparisonFilter{}
			}
			if err := m.Comparison.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *DurationFilter) 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 ErrIntOverflowAccesslog
			}
			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: DurationFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DurationFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Comparison", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Comparison == nil {
				m.Comparison = &ComparisonFilter{}
			}
			if err := m.Comparison.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *NotHealthCheckFilter) 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 ErrIntOverflowAccesslog
			}
			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: NotHealthCheckFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NotHealthCheckFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *TraceableFilter) 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 ErrIntOverflowAccesslog
			}
			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: TraceableFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TraceableFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *RuntimeFilter) 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 ErrIntOverflowAccesslog
			}
			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: RuntimeFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RuntimeFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				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 ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RuntimeKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PercentSampled", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PercentSampled == nil {
				m.PercentSampled = &_type.FractionalPercent{}
			}
			if err := m.PercentSampled.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseIndependentRandomness", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseIndependentRandomness = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *AndFilter) 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 ErrIntOverflowAccesslog
			}
			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: AndFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AndFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filters = append(m.Filters, &AccessLogFilter{})
			if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *OrFilter) 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 ErrIntOverflowAccesslog
			}
			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: OrFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OrFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filters = append(m.Filters, &AccessLogFilter{})
			if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *HeaderFilter) 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 ErrIntOverflowAccesslog
			}
			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: HeaderFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeaderFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &route.HeaderMatcher{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *ResponseFlagFilter) 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 ErrIntOverflowAccesslog
			}
			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: ResponseFlagFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResponseFlagFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				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 ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Flags = append(m.Flags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *GrpcStatusFilter) 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 ErrIntOverflowAccesslog
			}
			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: GrpcStatusFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GrpcStatusFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v GrpcStatusFilter_Status
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAccesslog
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= GrpcStatusFilter_Status(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Statuses = append(m.Statuses, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAccesslog
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthAccesslog
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthAccesslog
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Statuses) == 0 {
					m.Statuses = make([]GrpcStatusFilter_Status, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v GrpcStatusFilter_Status
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowAccesslog
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= GrpcStatusFilter_Status(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Statuses = append(m.Statuses, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType)
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exclude", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Exclude = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 *ExtensionFilter) 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 ErrIntOverflowAccesslog
			}
			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: ExtensionFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExtensionFilter: 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 ErrIntOverflowAccesslog
				}
				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 ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Struct{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigType = &ExtensionFilter_Config{v}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowAccesslog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccesslog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccesslog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Any{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ConfigType = &ExtensionFilter_TypedConfig{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccesslog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccesslog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccesslog
			}
			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 skipAccesslog(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, ErrIntOverflowAccesslog
			}
			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, ErrIntOverflowAccesslog
				}
				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, ErrIntOverflowAccesslog
				}
				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, ErrInvalidLengthAccesslog
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthAccesslog
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowAccesslog
					}
					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 := skipAccesslog(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthAccesslog
				}
			}
			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 (
	ErrInvalidLengthAccesslog = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAccesslog   = fmt.Errorf("proto: integer overflow")
)
