// Code generated by protoc-gen-go. DO NOT EDIT.
// source: envoy/data/accesslog/v2/accesslog.proto

package envoy_data_accesslog_v2

import (
	fmt "fmt"
	_ "github.com/cncf/udpa/go/udpa/annotations"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v2/core"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	duration "github.com/golang/protobuf/ptypes/duration"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	math "math"
)

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

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

type HTTPAccessLogEntry_HTTPVersion int32

const (
	HTTPAccessLogEntry_PROTOCOL_UNSPECIFIED HTTPAccessLogEntry_HTTPVersion = 0
	HTTPAccessLogEntry_HTTP10               HTTPAccessLogEntry_HTTPVersion = 1
	HTTPAccessLogEntry_HTTP11               HTTPAccessLogEntry_HTTPVersion = 2
	HTTPAccessLogEntry_HTTP2                HTTPAccessLogEntry_HTTPVersion = 3
	HTTPAccessLogEntry_HTTP3                HTTPAccessLogEntry_HTTPVersion = 4
)

var HTTPAccessLogEntry_HTTPVersion_name = map[int32]string{
	0: "PROTOCOL_UNSPECIFIED",
	1: "HTTP10",
	2: "HTTP11",
	3: "HTTP2",
	4: "HTTP3",
}

var HTTPAccessLogEntry_HTTPVersion_value = map[string]int32{
	"PROTOCOL_UNSPECIFIED": 0,
	"HTTP10":               1,
	"HTTP11":               2,
	"HTTP2":                3,
	"HTTP3":                4,
}

func (x HTTPAccessLogEntry_HTTPVersion) String() string {
	return proto.EnumName(HTTPAccessLogEntry_HTTPVersion_name, int32(x))
}

func (HTTPAccessLogEntry_HTTPVersion) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{1, 0}
}

type ResponseFlags_Unauthorized_Reason int32

const (
	ResponseFlags_Unauthorized_REASON_UNSPECIFIED ResponseFlags_Unauthorized_Reason = 0
	ResponseFlags_Unauthorized_EXTERNAL_SERVICE   ResponseFlags_Unauthorized_Reason = 1
)

var ResponseFlags_Unauthorized_Reason_name = map[int32]string{
	0: "REASON_UNSPECIFIED",
	1: "EXTERNAL_SERVICE",
}

var ResponseFlags_Unauthorized_Reason_value = map[string]int32{
	"REASON_UNSPECIFIED": 0,
	"EXTERNAL_SERVICE":   1,
}

func (x ResponseFlags_Unauthorized_Reason) String() string {
	return proto.EnumName(ResponseFlags_Unauthorized_Reason_name, int32(x))
}

func (ResponseFlags_Unauthorized_Reason) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{4, 0, 0}
}

type TLSProperties_TLSVersion int32

const (
	TLSProperties_VERSION_UNSPECIFIED TLSProperties_TLSVersion = 0
	TLSProperties_TLSv1               TLSProperties_TLSVersion = 1
	TLSProperties_TLSv1_1             TLSProperties_TLSVersion = 2
	TLSProperties_TLSv1_2             TLSProperties_TLSVersion = 3
	TLSProperties_TLSv1_3             TLSProperties_TLSVersion = 4
)

var TLSProperties_TLSVersion_name = map[int32]string{
	0: "VERSION_UNSPECIFIED",
	1: "TLSv1",
	2: "TLSv1_1",
	3: "TLSv1_2",
	4: "TLSv1_3",
}

var TLSProperties_TLSVersion_value = map[string]int32{
	"VERSION_UNSPECIFIED": 0,
	"TLSv1":               1,
	"TLSv1_1":             2,
	"TLSv1_2":             3,
	"TLSv1_3":             4,
}

func (x TLSProperties_TLSVersion) String() string {
	return proto.EnumName(TLSProperties_TLSVersion_name, int32(x))
}

func (TLSProperties_TLSVersion) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{5, 0}
}

type TCPAccessLogEntry struct {
	CommonProperties     *AccessLogCommon      `protobuf:"bytes,1,opt,name=common_properties,json=commonProperties,proto3" json:"common_properties,omitempty"`
	ConnectionProperties *ConnectionProperties `protobuf:"bytes,2,opt,name=connection_properties,json=connectionProperties,proto3" json:"connection_properties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *TCPAccessLogEntry) Reset()         { *m = TCPAccessLogEntry{} }
func (m *TCPAccessLogEntry) String() string { return proto.CompactTextString(m) }
func (*TCPAccessLogEntry) ProtoMessage()    {}
func (*TCPAccessLogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{0}
}

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

var xxx_messageInfo_TCPAccessLogEntry proto.InternalMessageInfo

func (m *TCPAccessLogEntry) GetCommonProperties() *AccessLogCommon {
	if m != nil {
		return m.CommonProperties
	}
	return nil
}

func (m *TCPAccessLogEntry) GetConnectionProperties() *ConnectionProperties {
	if m != nil {
		return m.ConnectionProperties
	}
	return nil
}

type HTTPAccessLogEntry struct {
	CommonProperties     *AccessLogCommon               `protobuf:"bytes,1,opt,name=common_properties,json=commonProperties,proto3" json:"common_properties,omitempty"`
	ProtocolVersion      HTTPAccessLogEntry_HTTPVersion `protobuf:"varint,2,opt,name=protocol_version,json=protocolVersion,proto3,enum=envoy.data.accesslog.v2.HTTPAccessLogEntry_HTTPVersion" json:"protocol_version,omitempty"`
	Request              *HTTPRequestProperties         `protobuf:"bytes,3,opt,name=request,proto3" json:"request,omitempty"`
	Response             *HTTPResponseProperties        `protobuf:"bytes,4,opt,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

func (m *HTTPAccessLogEntry) Reset()         { *m = HTTPAccessLogEntry{} }
func (m *HTTPAccessLogEntry) String() string { return proto.CompactTextString(m) }
func (*HTTPAccessLogEntry) ProtoMessage()    {}
func (*HTTPAccessLogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{1}
}

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

var xxx_messageInfo_HTTPAccessLogEntry proto.InternalMessageInfo

func (m *HTTPAccessLogEntry) GetCommonProperties() *AccessLogCommon {
	if m != nil {
		return m.CommonProperties
	}
	return nil
}

func (m *HTTPAccessLogEntry) GetProtocolVersion() HTTPAccessLogEntry_HTTPVersion {
	if m != nil {
		return m.ProtocolVersion
	}
	return HTTPAccessLogEntry_PROTOCOL_UNSPECIFIED
}

func (m *HTTPAccessLogEntry) GetRequest() *HTTPRequestProperties {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *HTTPAccessLogEntry) GetResponse() *HTTPResponseProperties {
	if m != nil {
		return m.Response
	}
	return nil
}

type ConnectionProperties struct {
	ReceivedBytes        uint64   `protobuf:"varint,1,opt,name=received_bytes,json=receivedBytes,proto3" json:"received_bytes,omitempty"`
	SentBytes            uint64   `protobuf:"varint,2,opt,name=sent_bytes,json=sentBytes,proto3" json:"sent_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectionProperties) Reset()         { *m = ConnectionProperties{} }
func (m *ConnectionProperties) String() string { return proto.CompactTextString(m) }
func (*ConnectionProperties) ProtoMessage()    {}
func (*ConnectionProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{2}
}

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

var xxx_messageInfo_ConnectionProperties proto.InternalMessageInfo

func (m *ConnectionProperties) GetReceivedBytes() uint64 {
	if m != nil {
		return m.ReceivedBytes
	}
	return 0
}

func (m *ConnectionProperties) GetSentBytes() uint64 {
	if m != nil {
		return m.SentBytes
	}
	return 0
}

type AccessLogCommon struct {
	SampleRate                     float64              `protobuf:"fixed64,1,opt,name=sample_rate,json=sampleRate,proto3" json:"sample_rate,omitempty"`
	DownstreamRemoteAddress        *core.Address        `protobuf:"bytes,2,opt,name=downstream_remote_address,json=downstreamRemoteAddress,proto3" json:"downstream_remote_address,omitempty"`
	DownstreamLocalAddress         *core.Address        `protobuf:"bytes,3,opt,name=downstream_local_address,json=downstreamLocalAddress,proto3" json:"downstream_local_address,omitempty"`
	TlsProperties                  *TLSProperties       `protobuf:"bytes,4,opt,name=tls_properties,json=tlsProperties,proto3" json:"tls_properties,omitempty"`
	StartTime                      *timestamp.Timestamp `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	TimeToLastRxByte               *duration.Duration   `protobuf:"bytes,6,opt,name=time_to_last_rx_byte,json=timeToLastRxByte,proto3" json:"time_to_last_rx_byte,omitempty"`
	TimeToFirstUpstreamTxByte      *duration.Duration   `protobuf:"bytes,7,opt,name=time_to_first_upstream_tx_byte,json=timeToFirstUpstreamTxByte,proto3" json:"time_to_first_upstream_tx_byte,omitempty"`
	TimeToLastUpstreamTxByte       *duration.Duration   `protobuf:"bytes,8,opt,name=time_to_last_upstream_tx_byte,json=timeToLastUpstreamTxByte,proto3" json:"time_to_last_upstream_tx_byte,omitempty"`
	TimeToFirstUpstreamRxByte      *duration.Duration   `protobuf:"bytes,9,opt,name=time_to_first_upstream_rx_byte,json=timeToFirstUpstreamRxByte,proto3" json:"time_to_first_upstream_rx_byte,omitempty"`
	TimeToLastUpstreamRxByte       *duration.Duration   `protobuf:"bytes,10,opt,name=time_to_last_upstream_rx_byte,json=timeToLastUpstreamRxByte,proto3" json:"time_to_last_upstream_rx_byte,omitempty"`
	TimeToFirstDownstreamTxByte    *duration.Duration   `protobuf:"bytes,11,opt,name=time_to_first_downstream_tx_byte,json=timeToFirstDownstreamTxByte,proto3" json:"time_to_first_downstream_tx_byte,omitempty"`
	TimeToLastDownstreamTxByte     *duration.Duration   `protobuf:"bytes,12,opt,name=time_to_last_downstream_tx_byte,json=timeToLastDownstreamTxByte,proto3" json:"time_to_last_downstream_tx_byte,omitempty"`
	UpstreamRemoteAddress          *core.Address        `protobuf:"bytes,13,opt,name=upstream_remote_address,json=upstreamRemoteAddress,proto3" json:"upstream_remote_address,omitempty"`
	UpstreamLocalAddress           *core.Address        `protobuf:"bytes,14,opt,name=upstream_local_address,json=upstreamLocalAddress,proto3" json:"upstream_local_address,omitempty"`
	UpstreamCluster                string               `protobuf:"bytes,15,opt,name=upstream_cluster,json=upstreamCluster,proto3" json:"upstream_cluster,omitempty"`
	ResponseFlags                  *ResponseFlags       `protobuf:"bytes,16,opt,name=response_flags,json=responseFlags,proto3" json:"response_flags,omitempty"`
	Metadata                       *core.Metadata       `protobuf:"bytes,17,opt,name=metadata,proto3" json:"metadata,omitempty"`
	UpstreamTransportFailureReason string               `protobuf:"bytes,18,opt,name=upstream_transport_failure_reason,json=upstreamTransportFailureReason,proto3" json:"upstream_transport_failure_reason,omitempty"`
	RouteName                      string               `protobuf:"bytes,19,opt,name=route_name,json=routeName,proto3" json:"route_name,omitempty"`
	DownstreamDirectRemoteAddress  *core.Address        `protobuf:"bytes,20,opt,name=downstream_direct_remote_address,json=downstreamDirectRemoteAddress,proto3" json:"downstream_direct_remote_address,omitempty"`
	FilterStateObjects             map[string]*any.Any  `protobuf:"bytes,21,rep,name=filter_state_objects,json=filterStateObjects,proto3" json:"filter_state_objects,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral           struct{}             `json:"-"`
	XXX_unrecognized               []byte               `json:"-"`
	XXX_sizecache                  int32                `json:"-"`
}

func (m *AccessLogCommon) Reset()         { *m = AccessLogCommon{} }
func (m *AccessLogCommon) String() string { return proto.CompactTextString(m) }
func (*AccessLogCommon) ProtoMessage()    {}
func (*AccessLogCommon) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{3}
}

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

var xxx_messageInfo_AccessLogCommon proto.InternalMessageInfo

func (m *AccessLogCommon) GetSampleRate() float64 {
	if m != nil {
		return m.SampleRate
	}
	return 0
}

func (m *AccessLogCommon) GetDownstreamRemoteAddress() *core.Address {
	if m != nil {
		return m.DownstreamRemoteAddress
	}
	return nil
}

func (m *AccessLogCommon) GetDownstreamLocalAddress() *core.Address {
	if m != nil {
		return m.DownstreamLocalAddress
	}
	return nil
}

func (m *AccessLogCommon) GetTlsProperties() *TLSProperties {
	if m != nil {
		return m.TlsProperties
	}
	return nil
}

func (m *AccessLogCommon) GetStartTime() *timestamp.Timestamp {
	if m != nil {
		return m.StartTime
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToLastRxByte() *duration.Duration {
	if m != nil {
		return m.TimeToLastRxByte
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToFirstUpstreamTxByte() *duration.Duration {
	if m != nil {
		return m.TimeToFirstUpstreamTxByte
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToLastUpstreamTxByte() *duration.Duration {
	if m != nil {
		return m.TimeToLastUpstreamTxByte
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToFirstUpstreamRxByte() *duration.Duration {
	if m != nil {
		return m.TimeToFirstUpstreamRxByte
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToLastUpstreamRxByte() *duration.Duration {
	if m != nil {
		return m.TimeToLastUpstreamRxByte
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToFirstDownstreamTxByte() *duration.Duration {
	if m != nil {
		return m.TimeToFirstDownstreamTxByte
	}
	return nil
}

func (m *AccessLogCommon) GetTimeToLastDownstreamTxByte() *duration.Duration {
	if m != nil {
		return m.TimeToLastDownstreamTxByte
	}
	return nil
}

func (m *AccessLogCommon) GetUpstreamRemoteAddress() *core.Address {
	if m != nil {
		return m.UpstreamRemoteAddress
	}
	return nil
}

func (m *AccessLogCommon) GetUpstreamLocalAddress() *core.Address {
	if m != nil {
		return m.UpstreamLocalAddress
	}
	return nil
}

func (m *AccessLogCommon) GetUpstreamCluster() string {
	if m != nil {
		return m.UpstreamCluster
	}
	return ""
}

func (m *AccessLogCommon) GetResponseFlags() *ResponseFlags {
	if m != nil {
		return m.ResponseFlags
	}
	return nil
}

func (m *AccessLogCommon) GetMetadata() *core.Metadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *AccessLogCommon) GetUpstreamTransportFailureReason() string {
	if m != nil {
		return m.UpstreamTransportFailureReason
	}
	return ""
}

func (m *AccessLogCommon) GetRouteName() string {
	if m != nil {
		return m.RouteName
	}
	return ""
}

func (m *AccessLogCommon) GetDownstreamDirectRemoteAddress() *core.Address {
	if m != nil {
		return m.DownstreamDirectRemoteAddress
	}
	return nil
}

func (m *AccessLogCommon) GetFilterStateObjects() map[string]*any.Any {
	if m != nil {
		return m.FilterStateObjects
	}
	return nil
}

type ResponseFlags struct {
	FailedLocalHealthcheck          bool                        `protobuf:"varint,1,opt,name=failed_local_healthcheck,json=failedLocalHealthcheck,proto3" json:"failed_local_healthcheck,omitempty"`
	NoHealthyUpstream               bool                        `protobuf:"varint,2,opt,name=no_healthy_upstream,json=noHealthyUpstream,proto3" json:"no_healthy_upstream,omitempty"`
	UpstreamRequestTimeout          bool                        `protobuf:"varint,3,opt,name=upstream_request_timeout,json=upstreamRequestTimeout,proto3" json:"upstream_request_timeout,omitempty"`
	LocalReset                      bool                        `protobuf:"varint,4,opt,name=local_reset,json=localReset,proto3" json:"local_reset,omitempty"`
	UpstreamRemoteReset             bool                        `protobuf:"varint,5,opt,name=upstream_remote_reset,json=upstreamRemoteReset,proto3" json:"upstream_remote_reset,omitempty"`
	UpstreamConnectionFailure       bool                        `protobuf:"varint,6,opt,name=upstream_connection_failure,json=upstreamConnectionFailure,proto3" json:"upstream_connection_failure,omitempty"`
	UpstreamConnectionTermination   bool                        `protobuf:"varint,7,opt,name=upstream_connection_termination,json=upstreamConnectionTermination,proto3" json:"upstream_connection_termination,omitempty"`
	UpstreamOverflow                bool                        `protobuf:"varint,8,opt,name=upstream_overflow,json=upstreamOverflow,proto3" json:"upstream_overflow,omitempty"`
	NoRouteFound                    bool                        `protobuf:"varint,9,opt,name=no_route_found,json=noRouteFound,proto3" json:"no_route_found,omitempty"`
	DelayInjected                   bool                        `protobuf:"varint,10,opt,name=delay_injected,json=delayInjected,proto3" json:"delay_injected,omitempty"`
	FaultInjected                   bool                        `protobuf:"varint,11,opt,name=fault_injected,json=faultInjected,proto3" json:"fault_injected,omitempty"`
	RateLimited                     bool                        `protobuf:"varint,12,opt,name=rate_limited,json=rateLimited,proto3" json:"rate_limited,omitempty"`
	UnauthorizedDetails             *ResponseFlags_Unauthorized `protobuf:"bytes,13,opt,name=unauthorized_details,json=unauthorizedDetails,proto3" json:"unauthorized_details,omitempty"`
	RateLimitServiceError           bool                        `protobuf:"varint,14,opt,name=rate_limit_service_error,json=rateLimitServiceError,proto3" json:"rate_limit_service_error,omitempty"`
	DownstreamConnectionTermination bool                        `protobuf:"varint,15,opt,name=downstream_connection_termination,json=downstreamConnectionTermination,proto3" json:"downstream_connection_termination,omitempty"`
	UpstreamRetryLimitExceeded      bool                        `protobuf:"varint,16,opt,name=upstream_retry_limit_exceeded,json=upstreamRetryLimitExceeded,proto3" json:"upstream_retry_limit_exceeded,omitempty"`
	StreamIdleTimeout               bool                        `protobuf:"varint,17,opt,name=stream_idle_timeout,json=streamIdleTimeout,proto3" json:"stream_idle_timeout,omitempty"`
	InvalidEnvoyRequestHeaders      bool                        `protobuf:"varint,18,opt,name=invalid_envoy_request_headers,json=invalidEnvoyRequestHeaders,proto3" json:"invalid_envoy_request_headers,omitempty"`
	DownstreamProtocolError         bool                        `protobuf:"varint,19,opt,name=downstream_protocol_error,json=downstreamProtocolError,proto3" json:"downstream_protocol_error,omitempty"`
	XXX_NoUnkeyedLiteral            struct{}                    `json:"-"`
	XXX_unrecognized                []byte                      `json:"-"`
	XXX_sizecache                   int32                       `json:"-"`
}

func (m *ResponseFlags) Reset()         { *m = ResponseFlags{} }
func (m *ResponseFlags) String() string { return proto.CompactTextString(m) }
func (*ResponseFlags) ProtoMessage()    {}
func (*ResponseFlags) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{4}
}

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

var xxx_messageInfo_ResponseFlags proto.InternalMessageInfo

func (m *ResponseFlags) GetFailedLocalHealthcheck() bool {
	if m != nil {
		return m.FailedLocalHealthcheck
	}
	return false
}

func (m *ResponseFlags) GetNoHealthyUpstream() bool {
	if m != nil {
		return m.NoHealthyUpstream
	}
	return false
}

func (m *ResponseFlags) GetUpstreamRequestTimeout() bool {
	if m != nil {
		return m.UpstreamRequestTimeout
	}
	return false
}

func (m *ResponseFlags) GetLocalReset() bool {
	if m != nil {
		return m.LocalReset
	}
	return false
}

func (m *ResponseFlags) GetUpstreamRemoteReset() bool {
	if m != nil {
		return m.UpstreamRemoteReset
	}
	return false
}

func (m *ResponseFlags) GetUpstreamConnectionFailure() bool {
	if m != nil {
		return m.UpstreamConnectionFailure
	}
	return false
}

func (m *ResponseFlags) GetUpstreamConnectionTermination() bool {
	if m != nil {
		return m.UpstreamConnectionTermination
	}
	return false
}

func (m *ResponseFlags) GetUpstreamOverflow() bool {
	if m != nil {
		return m.UpstreamOverflow
	}
	return false
}

func (m *ResponseFlags) GetNoRouteFound() bool {
	if m != nil {
		return m.NoRouteFound
	}
	return false
}

func (m *ResponseFlags) GetDelayInjected() bool {
	if m != nil {
		return m.DelayInjected
	}
	return false
}

func (m *ResponseFlags) GetFaultInjected() bool {
	if m != nil {
		return m.FaultInjected
	}
	return false
}

func (m *ResponseFlags) GetRateLimited() bool {
	if m != nil {
		return m.RateLimited
	}
	return false
}

func (m *ResponseFlags) GetUnauthorizedDetails() *ResponseFlags_Unauthorized {
	if m != nil {
		return m.UnauthorizedDetails
	}
	return nil
}

func (m *ResponseFlags) GetRateLimitServiceError() bool {
	if m != nil {
		return m.RateLimitServiceError
	}
	return false
}

func (m *ResponseFlags) GetDownstreamConnectionTermination() bool {
	if m != nil {
		return m.DownstreamConnectionTermination
	}
	return false
}

func (m *ResponseFlags) GetUpstreamRetryLimitExceeded() bool {
	if m != nil {
		return m.UpstreamRetryLimitExceeded
	}
	return false
}

func (m *ResponseFlags) GetStreamIdleTimeout() bool {
	if m != nil {
		return m.StreamIdleTimeout
	}
	return false
}

func (m *ResponseFlags) GetInvalidEnvoyRequestHeaders() bool {
	if m != nil {
		return m.InvalidEnvoyRequestHeaders
	}
	return false
}

func (m *ResponseFlags) GetDownstreamProtocolError() bool {
	if m != nil {
		return m.DownstreamProtocolError
	}
	return false
}

type ResponseFlags_Unauthorized struct {
	Reason               ResponseFlags_Unauthorized_Reason `protobuf:"varint,1,opt,name=reason,proto3,enum=envoy.data.accesslog.v2.ResponseFlags_Unauthorized_Reason" json:"reason,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *ResponseFlags_Unauthorized) Reset()         { *m = ResponseFlags_Unauthorized{} }
func (m *ResponseFlags_Unauthorized) String() string { return proto.CompactTextString(m) }
func (*ResponseFlags_Unauthorized) ProtoMessage()    {}
func (*ResponseFlags_Unauthorized) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{4, 0}
}

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

var xxx_messageInfo_ResponseFlags_Unauthorized proto.InternalMessageInfo

func (m *ResponseFlags_Unauthorized) GetReason() ResponseFlags_Unauthorized_Reason {
	if m != nil {
		return m.Reason
	}
	return ResponseFlags_Unauthorized_REASON_UNSPECIFIED
}

type TLSProperties struct {
	TlsVersion                 TLSProperties_TLSVersion             `protobuf:"varint,1,opt,name=tls_version,json=tlsVersion,proto3,enum=envoy.data.accesslog.v2.TLSProperties_TLSVersion" json:"tls_version,omitempty"`
	TlsCipherSuite             *wrappers.UInt32Value                `protobuf:"bytes,2,opt,name=tls_cipher_suite,json=tlsCipherSuite,proto3" json:"tls_cipher_suite,omitempty"`
	TlsSniHostname             string                               `protobuf:"bytes,3,opt,name=tls_sni_hostname,json=tlsSniHostname,proto3" json:"tls_sni_hostname,omitempty"`
	LocalCertificateProperties *TLSProperties_CertificateProperties `protobuf:"bytes,4,opt,name=local_certificate_properties,json=localCertificateProperties,proto3" json:"local_certificate_properties,omitempty"`
	PeerCertificateProperties  *TLSProperties_CertificateProperties `protobuf:"bytes,5,opt,name=peer_certificate_properties,json=peerCertificateProperties,proto3" json:"peer_certificate_properties,omitempty"`
	TlsSessionId               string                               `protobuf:"bytes,6,opt,name=tls_session_id,json=tlsSessionId,proto3" json:"tls_session_id,omitempty"`
	XXX_NoUnkeyedLiteral       struct{}                             `json:"-"`
	XXX_unrecognized           []byte                               `json:"-"`
	XXX_sizecache              int32                                `json:"-"`
}

func (m *TLSProperties) Reset()         { *m = TLSProperties{} }
func (m *TLSProperties) String() string { return proto.CompactTextString(m) }
func (*TLSProperties) ProtoMessage()    {}
func (*TLSProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{5}
}

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

var xxx_messageInfo_TLSProperties proto.InternalMessageInfo

func (m *TLSProperties) GetTlsVersion() TLSProperties_TLSVersion {
	if m != nil {
		return m.TlsVersion
	}
	return TLSProperties_VERSION_UNSPECIFIED
}

func (m *TLSProperties) GetTlsCipherSuite() *wrappers.UInt32Value {
	if m != nil {
		return m.TlsCipherSuite
	}
	return nil
}

func (m *TLSProperties) GetTlsSniHostname() string {
	if m != nil {
		return m.TlsSniHostname
	}
	return ""
}

func (m *TLSProperties) GetLocalCertificateProperties() *TLSProperties_CertificateProperties {
	if m != nil {
		return m.LocalCertificateProperties
	}
	return nil
}

func (m *TLSProperties) GetPeerCertificateProperties() *TLSProperties_CertificateProperties {
	if m != nil {
		return m.PeerCertificateProperties
	}
	return nil
}

func (m *TLSProperties) GetTlsSessionId() string {
	if m != nil {
		return m.TlsSessionId
	}
	return ""
}

type TLSProperties_CertificateProperties struct {
	SubjectAltName       []*TLSProperties_CertificateProperties_SubjectAltName `protobuf:"bytes,1,rep,name=subject_alt_name,json=subjectAltName,proto3" json:"subject_alt_name,omitempty"`
	Subject              string                                                `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                              `json:"-"`
	XXX_unrecognized     []byte                                                `json:"-"`
	XXX_sizecache        int32                                                 `json:"-"`
}

func (m *TLSProperties_CertificateProperties) Reset()         { *m = TLSProperties_CertificateProperties{} }
func (m *TLSProperties_CertificateProperties) String() string { return proto.CompactTextString(m) }
func (*TLSProperties_CertificateProperties) ProtoMessage()    {}
func (*TLSProperties_CertificateProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{5, 0}
}

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

var xxx_messageInfo_TLSProperties_CertificateProperties proto.InternalMessageInfo

func (m *TLSProperties_CertificateProperties) GetSubjectAltName() []*TLSProperties_CertificateProperties_SubjectAltName {
	if m != nil {
		return m.SubjectAltName
	}
	return nil
}

func (m *TLSProperties_CertificateProperties) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

type TLSProperties_CertificateProperties_SubjectAltName struct {
	// Types that are valid to be assigned to San:
	//	*TLSProperties_CertificateProperties_SubjectAltName_Uri
	//	*TLSProperties_CertificateProperties_SubjectAltName_Dns
	San                  isTLSProperties_CertificateProperties_SubjectAltName_San `protobuf_oneof:"san"`
	XXX_NoUnkeyedLiteral struct{}                                                 `json:"-"`
	XXX_unrecognized     []byte                                                   `json:"-"`
	XXX_sizecache        int32                                                    `json:"-"`
}

func (m *TLSProperties_CertificateProperties_SubjectAltName) Reset() {
	*m = TLSProperties_CertificateProperties_SubjectAltName{}
}
func (m *TLSProperties_CertificateProperties_SubjectAltName) String() string {
	return proto.CompactTextString(m)
}
func (*TLSProperties_CertificateProperties_SubjectAltName) ProtoMessage() {}
func (*TLSProperties_CertificateProperties_SubjectAltName) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{5, 0, 0}
}

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

var xxx_messageInfo_TLSProperties_CertificateProperties_SubjectAltName proto.InternalMessageInfo

type isTLSProperties_CertificateProperties_SubjectAltName_San interface {
	isTLSProperties_CertificateProperties_SubjectAltName_San()
}

type TLSProperties_CertificateProperties_SubjectAltName_Uri struct {
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3,oneof"`
}

type TLSProperties_CertificateProperties_SubjectAltName_Dns struct {
	Dns string `protobuf:"bytes,2,opt,name=dns,proto3,oneof"`
}

func (*TLSProperties_CertificateProperties_SubjectAltName_Uri) isTLSProperties_CertificateProperties_SubjectAltName_San() {
}

func (*TLSProperties_CertificateProperties_SubjectAltName_Dns) isTLSProperties_CertificateProperties_SubjectAltName_San() {
}

func (m *TLSProperties_CertificateProperties_SubjectAltName) GetSan() isTLSProperties_CertificateProperties_SubjectAltName_San {
	if m != nil {
		return m.San
	}
	return nil
}

func (m *TLSProperties_CertificateProperties_SubjectAltName) GetUri() string {
	if x, ok := m.GetSan().(*TLSProperties_CertificateProperties_SubjectAltName_Uri); ok {
		return x.Uri
	}
	return ""
}

func (m *TLSProperties_CertificateProperties_SubjectAltName) GetDns() string {
	if x, ok := m.GetSan().(*TLSProperties_CertificateProperties_SubjectAltName_Dns); ok {
		return x.Dns
	}
	return ""
}

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

type HTTPRequestProperties struct {
	RequestMethod        core.RequestMethod    `protobuf:"varint,1,opt,name=request_method,json=requestMethod,proto3,enum=envoy.api.v2.core.RequestMethod" json:"request_method,omitempty"`
	Scheme               string                `protobuf:"bytes,2,opt,name=scheme,proto3" json:"scheme,omitempty"`
	Authority            string                `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"`
	Port                 *wrappers.UInt32Value `protobuf:"bytes,4,opt,name=port,proto3" json:"port,omitempty"`
	Path                 string                `protobuf:"bytes,5,opt,name=path,proto3" json:"path,omitempty"`
	UserAgent            string                `protobuf:"bytes,6,opt,name=user_agent,json=userAgent,proto3" json:"user_agent,omitempty"`
	Referer              string                `protobuf:"bytes,7,opt,name=referer,proto3" json:"referer,omitempty"`
	ForwardedFor         string                `protobuf:"bytes,8,opt,name=forwarded_for,json=forwardedFor,proto3" json:"forwarded_for,omitempty"`
	RequestId            string                `protobuf:"bytes,9,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	OriginalPath         string                `protobuf:"bytes,10,opt,name=original_path,json=originalPath,proto3" json:"original_path,omitempty"`
	RequestHeadersBytes  uint64                `protobuf:"varint,11,opt,name=request_headers_bytes,json=requestHeadersBytes,proto3" json:"request_headers_bytes,omitempty"`
	RequestBodyBytes     uint64                `protobuf:"varint,12,opt,name=request_body_bytes,json=requestBodyBytes,proto3" json:"request_body_bytes,omitempty"`
	RequestHeaders       map[string]string     `protobuf:"bytes,13,rep,name=request_headers,json=requestHeaders,proto3" json:"request_headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *HTTPRequestProperties) Reset()         { *m = HTTPRequestProperties{} }
func (m *HTTPRequestProperties) String() string { return proto.CompactTextString(m) }
func (*HTTPRequestProperties) ProtoMessage()    {}
func (*HTTPRequestProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{6}
}

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

var xxx_messageInfo_HTTPRequestProperties proto.InternalMessageInfo

func (m *HTTPRequestProperties) GetRequestMethod() core.RequestMethod {
	if m != nil {
		return m.RequestMethod
	}
	return core.RequestMethod_METHOD_UNSPECIFIED
}

func (m *HTTPRequestProperties) GetScheme() string {
	if m != nil {
		return m.Scheme
	}
	return ""
}

func (m *HTTPRequestProperties) GetAuthority() string {
	if m != nil {
		return m.Authority
	}
	return ""
}

func (m *HTTPRequestProperties) GetPort() *wrappers.UInt32Value {
	if m != nil {
		return m.Port
	}
	return nil
}

func (m *HTTPRequestProperties) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *HTTPRequestProperties) GetUserAgent() string {
	if m != nil {
		return m.UserAgent
	}
	return ""
}

func (m *HTTPRequestProperties) GetReferer() string {
	if m != nil {
		return m.Referer
	}
	return ""
}

func (m *HTTPRequestProperties) GetForwardedFor() string {
	if m != nil {
		return m.ForwardedFor
	}
	return ""
}

func (m *HTTPRequestProperties) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *HTTPRequestProperties) GetOriginalPath() string {
	if m != nil {
		return m.OriginalPath
	}
	return ""
}

func (m *HTTPRequestProperties) GetRequestHeadersBytes() uint64 {
	if m != nil {
		return m.RequestHeadersBytes
	}
	return 0
}

func (m *HTTPRequestProperties) GetRequestBodyBytes() uint64 {
	if m != nil {
		return m.RequestBodyBytes
	}
	return 0
}

func (m *HTTPRequestProperties) GetRequestHeaders() map[string]string {
	if m != nil {
		return m.RequestHeaders
	}
	return nil
}

type HTTPResponseProperties struct {
	ResponseCode         *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=response_code,json=responseCode,proto3" json:"response_code,omitempty"`
	ResponseHeadersBytes uint64                `protobuf:"varint,2,opt,name=response_headers_bytes,json=responseHeadersBytes,proto3" json:"response_headers_bytes,omitempty"`
	ResponseBodyBytes    uint64                `protobuf:"varint,3,opt,name=response_body_bytes,json=responseBodyBytes,proto3" json:"response_body_bytes,omitempty"`
	ResponseHeaders      map[string]string     `protobuf:"bytes,4,rep,name=response_headers,json=responseHeaders,proto3" json:"response_headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ResponseTrailers     map[string]string     `protobuf:"bytes,5,rep,name=response_trailers,json=responseTrailers,proto3" json:"response_trailers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ResponseCodeDetails  string                `protobuf:"bytes,6,opt,name=response_code_details,json=responseCodeDetails,proto3" json:"response_code_details,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *HTTPResponseProperties) Reset()         { *m = HTTPResponseProperties{} }
func (m *HTTPResponseProperties) String() string { return proto.CompactTextString(m) }
func (*HTTPResponseProperties) ProtoMessage()    {}
func (*HTTPResponseProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_ca1a3c8f3c17c754, []int{7}
}

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

var xxx_messageInfo_HTTPResponseProperties proto.InternalMessageInfo

func (m *HTTPResponseProperties) GetResponseCode() *wrappers.UInt32Value {
	if m != nil {
		return m.ResponseCode
	}
	return nil
}

func (m *HTTPResponseProperties) GetResponseHeadersBytes() uint64 {
	if m != nil {
		return m.ResponseHeadersBytes
	}
	return 0
}

func (m *HTTPResponseProperties) GetResponseBodyBytes() uint64 {
	if m != nil {
		return m.ResponseBodyBytes
	}
	return 0
}

func (m *HTTPResponseProperties) GetResponseHeaders() map[string]string {
	if m != nil {
		return m.ResponseHeaders
	}
	return nil
}

func (m *HTTPResponseProperties) GetResponseTrailers() map[string]string {
	if m != nil {
		return m.ResponseTrailers
	}
	return nil
}

func (m *HTTPResponseProperties) GetResponseCodeDetails() string {
	if m != nil {
		return m.ResponseCodeDetails
	}
	return ""
}

func init() {
	proto.RegisterEnum("envoy.data.accesslog.v2.HTTPAccessLogEntry_HTTPVersion", HTTPAccessLogEntry_HTTPVersion_name, HTTPAccessLogEntry_HTTPVersion_value)
	proto.RegisterEnum("envoy.data.accesslog.v2.ResponseFlags_Unauthorized_Reason", ResponseFlags_Unauthorized_Reason_name, ResponseFlags_Unauthorized_Reason_value)
	proto.RegisterEnum("envoy.data.accesslog.v2.TLSProperties_TLSVersion", TLSProperties_TLSVersion_name, TLSProperties_TLSVersion_value)
	proto.RegisterType((*TCPAccessLogEntry)(nil), "envoy.data.accesslog.v2.TCPAccessLogEntry")
	proto.RegisterType((*HTTPAccessLogEntry)(nil), "envoy.data.accesslog.v2.HTTPAccessLogEntry")
	proto.RegisterType((*ConnectionProperties)(nil), "envoy.data.accesslog.v2.ConnectionProperties")
	proto.RegisterType((*AccessLogCommon)(nil), "envoy.data.accesslog.v2.AccessLogCommon")
	proto.RegisterMapType((map[string]*any.Any)(nil), "envoy.data.accesslog.v2.AccessLogCommon.FilterStateObjectsEntry")
	proto.RegisterType((*ResponseFlags)(nil), "envoy.data.accesslog.v2.ResponseFlags")
	proto.RegisterType((*ResponseFlags_Unauthorized)(nil), "envoy.data.accesslog.v2.ResponseFlags.Unauthorized")
	proto.RegisterType((*TLSProperties)(nil), "envoy.data.accesslog.v2.TLSProperties")
	proto.RegisterType((*TLSProperties_CertificateProperties)(nil), "envoy.data.accesslog.v2.TLSProperties.CertificateProperties")
	proto.RegisterType((*TLSProperties_CertificateProperties_SubjectAltName)(nil), "envoy.data.accesslog.v2.TLSProperties.CertificateProperties.SubjectAltName")
	proto.RegisterType((*HTTPRequestProperties)(nil), "envoy.data.accesslog.v2.HTTPRequestProperties")
	proto.RegisterMapType((map[string]string)(nil), "envoy.data.accesslog.v2.HTTPRequestProperties.RequestHeadersEntry")
	proto.RegisterType((*HTTPResponseProperties)(nil), "envoy.data.accesslog.v2.HTTPResponseProperties")
	proto.RegisterMapType((map[string]string)(nil), "envoy.data.accesslog.v2.HTTPResponseProperties.ResponseHeadersEntry")
	proto.RegisterMapType((map[string]string)(nil), "envoy.data.accesslog.v2.HTTPResponseProperties.ResponseTrailersEntry")
}

func init() {
	proto.RegisterFile("envoy/data/accesslog/v2/accesslog.proto", fileDescriptor_ca1a3c8f3c17c754)
}

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