// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pdata/xpdata/request/internal/request.proto

package internal

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"

	v1 "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1"
	v13 "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1"
	v12 "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1"
	v1development "go.opentelemetry.io/collector/pdata/internal/data/protogen/profiles/v1development"
	v11 "go.opentelemetry.io/collector/pdata/internal/data/protogen/trace/v1"
)

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

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

// SpanContext represents a span context encoded associated with a telemetry export request.
type SpanContext struct {
	TraceId    []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
	SpanId     []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"`
	TraceFlags uint32 `protobuf:"fixed32,3,opt,name=trace_flags,json=traceFlags,proto3" json:"trace_flags,omitempty"`
	TraceState string `protobuf:"bytes,4,opt,name=trace_state,json=traceState,proto3" json:"trace_state,omitempty"`
	Remote     bool   `protobuf:"varint,5,opt,name=remote,proto3" json:"remote,omitempty"`
}

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

var xxx_messageInfo_SpanContext proto.InternalMessageInfo

func (m *SpanContext) GetTraceId() []byte {
	if m != nil {
		return m.TraceId
	}
	return nil
}

func (m *SpanContext) GetSpanId() []byte {
	if m != nil {
		return m.SpanId
	}
	return nil
}

func (m *SpanContext) GetTraceFlags() uint32 {
	if m != nil {
		return m.TraceFlags
	}
	return 0
}

func (m *SpanContext) GetTraceState() string {
	if m != nil {
		return m.TraceState
	}
	return ""
}

func (m *SpanContext) GetRemote() bool {
	if m != nil {
		return m.Remote
	}
	return false
}

type IPAddr struct {
	Ip   []byte `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
}

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

var xxx_messageInfo_IPAddr proto.InternalMessageInfo

func (m *IPAddr) GetIp() []byte {
	if m != nil {
		return m.Ip
	}
	return nil
}

func (m *IPAddr) GetZone() string {
	if m != nil {
		return m.Zone
	}
	return ""
}

type TCPAddr struct {
	Ip   []byte `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Port int64  `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Zone string `protobuf:"bytes,3,opt,name=zone,proto3" json:"zone,omitempty"`
}

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

var xxx_messageInfo_TCPAddr proto.InternalMessageInfo

func (m *TCPAddr) GetIp() []byte {
	if m != nil {
		return m.Ip
	}
	return nil
}

func (m *TCPAddr) GetPort() int64 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *TCPAddr) GetZone() string {
	if m != nil {
		return m.Zone
	}
	return ""
}

type UDPAddr struct {
	Ip   []byte `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Port int64  `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Zone string `protobuf:"bytes,3,opt,name=zone,proto3" json:"zone,omitempty"`
}

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

var xxx_messageInfo_UDPAddr proto.InternalMessageInfo

func (m *UDPAddr) GetIp() []byte {
	if m != nil {
		return m.Ip
	}
	return nil
}

func (m *UDPAddr) GetPort() int64 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *UDPAddr) GetZone() string {
	if m != nil {
		return m.Zone
	}
	return ""
}

type UnixAddr struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Net  string `protobuf:"bytes,2,opt,name=net,proto3" json:"net,omitempty"`
}

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

var xxx_messageInfo_UnixAddr proto.InternalMessageInfo

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

func (m *UnixAddr) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

// RequestContext represents metadata associated with a telemetry export request.
type RequestContext struct {
	SpanContext *SpanContext `protobuf:"bytes,1,opt,name=span_context,json=spanContext,proto3" json:"span_context,omitempty"`
	// ClientMetadata contains additional metadata about the client making the request.
	ClientMetadata []v1.KeyValue `protobuf:"bytes,2,rep,name=client_metadata,json=clientMetadata,proto3" json:"client_metadata"`
	// ClientAddress contains the address of the client making the request.
	//
	// Types that are valid to be assigned to ClientAddress:
	//	*RequestContext_Ip
	//	*RequestContext_Tcp
	//	*RequestContext_Udp
	//	*RequestContext_Unix
	ClientAddress isRequestContext_ClientAddress `protobuf_oneof:"client_address"`
}

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

var xxx_messageInfo_RequestContext proto.InternalMessageInfo

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

type RequestContext_Ip struct {
	Ip *IPAddr `protobuf:"bytes,3,opt,name=ip,proto3,oneof" json:"ip,omitempty"`
}
type RequestContext_Tcp struct {
	Tcp *TCPAddr `protobuf:"bytes,4,opt,name=tcp,proto3,oneof" json:"tcp,omitempty"`
}
type RequestContext_Udp struct {
	Udp *UDPAddr `protobuf:"bytes,5,opt,name=udp,proto3,oneof" json:"udp,omitempty"`
}
type RequestContext_Unix struct {
	Unix *UnixAddr `protobuf:"bytes,6,opt,name=unix,proto3,oneof" json:"unix,omitempty"`
}

func (*RequestContext_Ip) isRequestContext_ClientAddress()   {}
func (*RequestContext_Tcp) isRequestContext_ClientAddress()  {}
func (*RequestContext_Udp) isRequestContext_ClientAddress()  {}
func (*RequestContext_Unix) isRequestContext_ClientAddress() {}

func (m *RequestContext) GetClientAddress() isRequestContext_ClientAddress {
	if m != nil {
		return m.ClientAddress
	}
	return nil
}

func (m *RequestContext) GetSpanContext() *SpanContext {
	if m != nil {
		return m.SpanContext
	}
	return nil
}

func (m *RequestContext) GetClientMetadata() []v1.KeyValue {
	if m != nil {
		return m.ClientMetadata
	}
	return nil
}

func (m *RequestContext) GetIp() *IPAddr {
	if x, ok := m.GetClientAddress().(*RequestContext_Ip); ok {
		return x.Ip
	}
	return nil
}

func (m *RequestContext) GetTcp() *TCPAddr {
	if x, ok := m.GetClientAddress().(*RequestContext_Tcp); ok {
		return x.Tcp
	}
	return nil
}

func (m *RequestContext) GetUdp() *UDPAddr {
	if x, ok := m.GetClientAddress().(*RequestContext_Udp); ok {
		return x.Udp
	}
	return nil
}

func (m *RequestContext) GetUnix() *UnixAddr {
	if x, ok := m.GetClientAddress().(*RequestContext_Unix); ok {
		return x.Unix
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RequestContext) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RequestContext_Ip)(nil),
		(*RequestContext_Tcp)(nil),
		(*RequestContext_Udp)(nil),
		(*RequestContext_Unix)(nil),
	}
}

type TracesRequest struct {
	FormatVersion  uint32          `protobuf:"fixed32,1,opt,name=format_version,json=formatVersion,proto3" json:"format_version,omitempty"`
	RequestContext *RequestContext `protobuf:"bytes,2,opt,name=request_context,json=requestContext,proto3" json:"request_context,omitempty"`
	TracesData     *v11.TracesData `protobuf:"bytes,3,opt,name=traces_data,json=tracesData,proto3" json:"traces_data,omitempty"`
}

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

var xxx_messageInfo_TracesRequest proto.InternalMessageInfo

func (m *TracesRequest) GetFormatVersion() uint32 {
	if m != nil {
		return m.FormatVersion
	}
	return 0
}

func (m *TracesRequest) GetRequestContext() *RequestContext {
	if m != nil {
		return m.RequestContext
	}
	return nil
}

func (m *TracesRequest) GetTracesData() *v11.TracesData {
	if m != nil {
		return m.TracesData
	}
	return nil
}

type MetricsRequest struct {
	FormatVersion  uint32           `protobuf:"fixed32,1,opt,name=format_version,json=formatVersion,proto3" json:"format_version,omitempty"`
	RequestContext *RequestContext  `protobuf:"bytes,2,opt,name=request_context,json=requestContext,proto3" json:"request_context,omitempty"`
	MetricsData    *v12.MetricsData `protobuf:"bytes,3,opt,name=metrics_data,json=metricsData,proto3" json:"metrics_data,omitempty"`
}

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

var xxx_messageInfo_MetricsRequest proto.InternalMessageInfo

func (m *MetricsRequest) GetFormatVersion() uint32 {
	if m != nil {
		return m.FormatVersion
	}
	return 0
}

func (m *MetricsRequest) GetRequestContext() *RequestContext {
	if m != nil {
		return m.RequestContext
	}
	return nil
}

func (m *MetricsRequest) GetMetricsData() *v12.MetricsData {
	if m != nil {
		return m.MetricsData
	}
	return nil
}

type LogsRequest struct {
	FormatVersion  uint32          `protobuf:"fixed32,1,opt,name=format_version,json=formatVersion,proto3" json:"format_version,omitempty"`
	RequestContext *RequestContext `protobuf:"bytes,2,opt,name=request_context,json=requestContext,proto3" json:"request_context,omitempty"`
	LogsData       *v13.LogsData   `protobuf:"bytes,3,opt,name=logs_data,json=logsData,proto3" json:"logs_data,omitempty"`
}

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

var xxx_messageInfo_LogsRequest proto.InternalMessageInfo

func (m *LogsRequest) GetFormatVersion() uint32 {
	if m != nil {
		return m.FormatVersion
	}
	return 0
}

func (m *LogsRequest) GetRequestContext() *RequestContext {
	if m != nil {
		return m.RequestContext
	}
	return nil
}

func (m *LogsRequest) GetLogsData() *v13.LogsData {
	if m != nil {
		return m.LogsData
	}
	return nil
}

type ProfilesRequest struct {
	FormatVersion  uint32                      `protobuf:"fixed32,1,opt,name=format_version,json=formatVersion,proto3" json:"format_version,omitempty"`
	RequestContext *RequestContext             `protobuf:"bytes,2,opt,name=request_context,json=requestContext,proto3" json:"request_context,omitempty"`
	ProfilesData   *v1development.ProfilesData `protobuf:"bytes,3,opt,name=profiles_data,json=profilesData,proto3" json:"profiles_data,omitempty"`
}

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

var xxx_messageInfo_ProfilesRequest proto.InternalMessageInfo

func (m *ProfilesRequest) GetFormatVersion() uint32 {
	if m != nil {
		return m.FormatVersion
	}
	return 0
}

func (m *ProfilesRequest) GetRequestContext() *RequestContext {
	if m != nil {
		return m.RequestContext
	}
	return nil
}

func (m *ProfilesRequest) GetProfilesData() *v1development.ProfilesData {
	if m != nil {
		return m.ProfilesData
	}
	return nil
}

func init() {
	proto.RegisterType((*SpanContext)(nil), "opentelemetry.collector.pdata.xpdata.internal.SpanContext")
	proto.RegisterType((*IPAddr)(nil), "opentelemetry.collector.pdata.xpdata.internal.IPAddr")
	proto.RegisterType((*TCPAddr)(nil), "opentelemetry.collector.pdata.xpdata.internal.TCPAddr")
	proto.RegisterType((*UDPAddr)(nil), "opentelemetry.collector.pdata.xpdata.internal.UDPAddr")
	proto.RegisterType((*UnixAddr)(nil), "opentelemetry.collector.pdata.xpdata.internal.UnixAddr")
	proto.RegisterType((*RequestContext)(nil), "opentelemetry.collector.pdata.xpdata.internal.RequestContext")
	proto.RegisterType((*TracesRequest)(nil), "opentelemetry.collector.pdata.xpdata.internal.TracesRequest")
	proto.RegisterType((*MetricsRequest)(nil), "opentelemetry.collector.pdata.xpdata.internal.MetricsRequest")
	proto.RegisterType((*LogsRequest)(nil), "opentelemetry.collector.pdata.xpdata.internal.LogsRequest")
	proto.RegisterType((*ProfilesRequest)(nil), "opentelemetry.collector.pdata.xpdata.internal.ProfilesRequest")
}

func init() {
	proto.RegisterFile("pdata/xpdata/request/internal/request.proto", fileDescriptor_b47c551a6764db21)
}

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

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

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

func (m *SpanContext) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Remote {
		i--
		if m.Remote {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.TraceState) > 0 {
		i -= len(m.TraceState)
		copy(dAtA[i:], m.TraceState)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.TraceState)))
		i--
		dAtA[i] = 0x22
	}
	if m.TraceFlags != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.TraceFlags))
		i--
		dAtA[i] = 0x1d
	}
	if len(m.SpanId) > 0 {
		i -= len(m.SpanId)
		copy(dAtA[i:], m.SpanId)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.SpanId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *IPAddr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Zone) > 0 {
		i -= len(m.Zone)
		copy(dAtA[i:], m.Zone)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Zone)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ip) > 0 {
		i -= len(m.Ip)
		copy(dAtA[i:], m.Ip)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Ip)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TCPAddr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Zone) > 0 {
		i -= len(m.Zone)
		copy(dAtA[i:], m.Zone)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Zone)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Port != 0 {
		i = encodeVarintRequest(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Ip) > 0 {
		i -= len(m.Ip)
		copy(dAtA[i:], m.Ip)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Ip)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *UDPAddr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Zone) > 0 {
		i -= len(m.Zone)
		copy(dAtA[i:], m.Zone)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Zone)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Port != 0 {
		i = encodeVarintRequest(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Ip) > 0 {
		i -= len(m.Ip)
		copy(dAtA[i:], m.Ip)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Ip)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *UnixAddr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Net) > 0 {
		i -= len(m.Net)
		copy(dAtA[i:], m.Net)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Net)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRequest(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *RequestContext) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ClientAddress != nil {
		{
			size := m.ClientAddress.Size()
			i -= size
			if _, err := m.ClientAddress.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.ClientMetadata) > 0 {
		for iNdEx := len(m.ClientMetadata) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ClientMetadata[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRequest(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.SpanContext != nil {
		{
			size, err := m.SpanContext.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *RequestContext_Udp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Udp != nil {
		{
			size, err := m.Udp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *RequestContext_Unix) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RequestContext_Unix) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Unix != nil {
		{
			size, err := m.Unix.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *TracesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TracesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TracesData != nil {
		{
			size, err := m.TracesData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.RequestContext != nil {
		{
			size, err := m.RequestContext.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.FormatVersion != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FormatVersion))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

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

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

func (m *MetricsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MetricsData != nil {
		{
			size, err := m.MetricsData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.RequestContext != nil {
		{
			size, err := m.RequestContext.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.FormatVersion != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FormatVersion))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogsData != nil {
		{
			size, err := m.LogsData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.RequestContext != nil {
		{
			size, err := m.RequestContext.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.FormatVersion != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FormatVersion))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProfilesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProfilesData != nil {
		{
			size, err := m.ProfilesData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.RequestContext != nil {
		{
			size, err := m.RequestContext.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRequest(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.FormatVersion != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FormatVersion))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func encodeVarintRequest(dAtA []byte, offset int, v uint64) int {
	offset -= sovRequest(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *SpanContext) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	l = len(m.SpanId)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.TraceFlags != 0 {
		n += 5
	}
	l = len(m.TraceState)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.Remote {
		n += 2
	}
	return n
}

func (m *IPAddr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ip)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	l = len(m.Zone)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *TCPAddr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ip)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovRequest(uint64(m.Port))
	}
	l = len(m.Zone)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *UDPAddr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ip)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovRequest(uint64(m.Port))
	}
	l = len(m.Zone)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *UnixAddr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	l = len(m.Net)
	if l > 0 {
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *RequestContext) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SpanContext != nil {
		l = m.SpanContext.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	if len(m.ClientMetadata) > 0 {
		for _, e := range m.ClientMetadata {
			l = e.Size()
			n += 1 + l + sovRequest(uint64(l))
		}
	}
	if m.ClientAddress != nil {
		n += m.ClientAddress.Size()
	}
	return n
}

func (m *RequestContext_Ip) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ip != nil {
		l = m.Ip.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}
func (m *RequestContext_Tcp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tcp != nil {
		l = m.Tcp.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}
func (m *RequestContext_Udp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Udp != nil {
		l = m.Udp.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}
func (m *RequestContext_Unix) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Unix != nil {
		l = m.Unix.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}
func (m *TracesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FormatVersion != 0 {
		n += 5
	}
	if m.RequestContext != nil {
		l = m.RequestContext.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.TracesData != nil {
		l = m.TracesData.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *MetricsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FormatVersion != 0 {
		n += 5
	}
	if m.RequestContext != nil {
		l = m.RequestContext.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.MetricsData != nil {
		l = m.MetricsData.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *LogsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FormatVersion != 0 {
		n += 5
	}
	if m.RequestContext != nil {
		l = m.RequestContext.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.LogsData != nil {
		l = m.LogsData.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func (m *ProfilesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FormatVersion != 0 {
		n += 5
	}
	if m.RequestContext != nil {
		l = m.RequestContext.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	if m.ProfilesData != nil {
		l = m.ProfilesData.Size()
		n += 1 + l + sovRequest(uint64(l))
	}
	return n
}

func sovRequest(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRequest(x uint64) (n int) {
	return sovRequest(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SpanContext) 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 ErrIntOverflowRequest
			}
			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: SpanContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpanContext: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
			if m.TraceId == nil {
				m.TraceId = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpanId", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpanId = append(m.SpanId[:0], dAtA[iNdEx:postIndex]...)
			if m.SpanId == nil {
				m.SpanId = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceFlags", wireType)
			}
			m.TraceFlags = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceFlags = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceState", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				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 ErrInvalidLengthRequest
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceState = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Remote = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPAddr) 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 ErrIntOverflowRequest
			}
			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: IPAddr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPAddr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ip = append(m.Ip[:0], dAtA[iNdEx:postIndex]...)
			if m.Ip == nil {
				m.Ip = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				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 ErrInvalidLengthRequest
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Zone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TCPAddr) 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 ErrIntOverflowRequest
			}
			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: TCPAddr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TCPAddr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ip = append(m.Ip[:0], dAtA[iNdEx:postIndex]...)
			if m.Ip == nil {
				m.Ip = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				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 ErrInvalidLengthRequest
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Zone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UDPAddr) 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 ErrIntOverflowRequest
			}
			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: UDPAddr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UDPAddr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ip = append(m.Ip[:0], dAtA[iNdEx:postIndex]...)
			if m.Ip == nil {
				m.Ip = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				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 ErrInvalidLengthRequest
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Zone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnixAddr) 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 ErrIntOverflowRequest
			}
			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: UnixAddr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnixAddr: 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 ErrIntOverflowRequest
				}
				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 ErrInvalidLengthRequest
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			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 Net", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				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 ErrInvalidLengthRequest
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Net = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RequestContext) 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 ErrIntOverflowRequest
			}
			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: RequestContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestContext: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpanContext", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SpanContext == nil {
				m.SpanContext = &SpanContext{}
			}
			if err := m.SpanContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientMetadata = append(m.ClientMetadata, v1.KeyValue{})
			if err := m.ClientMetadata[len(m.ClientMetadata)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IPAddr{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ClientAddress = &RequestContext_Ip{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tcp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TCPAddr{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ClientAddress = &RequestContext_Tcp{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Udp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UDPAddr{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ClientAddress = &RequestContext_Udp{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unix", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UnixAddr{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ClientAddress = &RequestContext_Unix{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracesRequest) 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 ErrIntOverflowRequest
			}
			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: TracesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FormatVersion", wireType)
			}
			m.FormatVersion = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.FormatVersion = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestContext", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestContext == nil {
				m.RequestContext = &RequestContext{}
			}
			if err := m.RequestContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracesData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TracesData == nil {
				m.TracesData = &v11.TracesData{}
			}
			if err := m.TracesData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetricsRequest) 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 ErrIntOverflowRequest
			}
			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: MetricsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FormatVersion", wireType)
			}
			m.FormatVersion = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.FormatVersion = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestContext", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestContext == nil {
				m.RequestContext = &RequestContext{}
			}
			if err := m.RequestContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricsData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricsData == nil {
				m.MetricsData = &v12.MetricsData{}
			}
			if err := m.MetricsData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogsRequest) 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 ErrIntOverflowRequest
			}
			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: LogsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FormatVersion", wireType)
			}
			m.FormatVersion = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.FormatVersion = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestContext", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestContext == nil {
				m.RequestContext = &RequestContext{}
			}
			if err := m.RequestContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogsData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogsData == nil {
				m.LogsData = &v13.LogsData{}
			}
			if err := m.LogsData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProfilesRequest) 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 ErrIntOverflowRequest
			}
			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: ProfilesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProfilesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FormatVersion", wireType)
			}
			m.FormatVersion = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.FormatVersion = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestContext", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequestContext == nil {
				m.RequestContext = &RequestContext{}
			}
			if err := m.RequestContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfilesData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRequest
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRequest
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProfilesData == nil {
				m.ProfilesData = &v1development.ProfilesData{}
			}
			if err := m.ProfilesData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRequest(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRequest
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRequest(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowRequest
			}
			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, ErrIntOverflowRequest
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRequest
				}
				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, ErrInvalidLengthRequest
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupRequest
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthRequest
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthRequest        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRequest          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRequest = fmt.Errorf("proto: unexpected end of group")
)
