event.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: entity/event.proto

package entity

import (
	fmt "fmt"
	io "io"
	math "math"
	time "time"

	_ "berty.tech/core/api/protobuf/graphql"
	_ "berty.tech/core/pkg/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	proto "github.com/golang/protobuf/proto"
	_ "github.com/golang/protobuf/ptypes/timestamp"
)

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

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

//
// enums
//
type Event_AckStatus int32

const (
	Event_UnknownAckStatus Event_AckStatus = 0
	// NotAcked is set default status that should be set directly at event creation.
	Event_NotAcked Event_AckStatus = 1
	// AckedAtLeastOnce is set on first received Ack event.
	Event_AckedAtLeastOnce Event_AckStatus = 2
	// AckedByAllContact is set when at least one device of each contact sent an Ack event.
	Event_AckedByAllContacts Event_AckStatus = 3
	// AckedByAllDevices is set when every device of every contact sent an Ack event.
	Event_AckedByAllDevices Event_AckStatus = 4
)

var Event_AckStatus_name = map[int32]string{
	0: "UnknownAckStatus",
	1: "NotAcked",
	2: "AckedAtLeastOnce",
	3: "AckedByAllContacts",
	4: "AckedByAllDevices",
}

var Event_AckStatus_value = map[string]int32{
	"UnknownAckStatus":   0,
	"NotAcked":           1,
	"AckedAtLeastOnce":   2,
	"AckedByAllContacts": 3,
	"AckedByAllDevices":  4,
}

func (x Event_AckStatus) String() string {
	return proto.EnumName(Event_AckStatus_name, int32(x))
}

func (Event_AckStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a0737e212f090f50, []int{0, 0}
}

type Event_SeenStatus int32

const (
	Event_UnknownSeenStatus Event_SeenStatus = 0
	// NotSeen is set at event creation.
	Event_NotSeen Event_SeenStatus = 1
	// SeenAtLeastOnce is set on first received Seen event.
	Event_SeenAtLeastOnce Event_SeenStatus = 2
	// SeenByAllContact is set when at least one device of each contact sent a Seen event.
	Event_SeenByAllContacts Event_SeenStatus = 3
)

var Event_SeenStatus_name = map[int32]string{
	0: "UnknownSeenStatus",
	1: "NotSeen",
	2: "SeenAtLeastOnce",
	3: "SeenByAllContacts",
}

var Event_SeenStatus_value = map[string]int32{
	"UnknownSeenStatus": 0,
	"NotSeen":           1,
	"SeenAtLeastOnce":   2,
	"SeenByAllContacts": 3,
}

func (x Event_SeenStatus) String() string {
	return proto.EnumName(Event_SeenStatus_name, int32(x))
}

func (Event_SeenStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a0737e212f090f50, []int{0, 1}
}

type Event_TargetType int32

const (
	Event_UnknownTargetType      Event_TargetType = 0
	Event_ToSpecificDevice       Event_TargetType = 1
	Event_ToSpecificContact      Event_TargetType = 2
	Event_ToAllContacts          Event_TargetType = 3
	Event_ToSpecificConversation Event_TargetType = 4
	// ToSelf is for another of our devices
	Event_ToSelf Event_TargetType = 5
)

var Event_TargetType_name = map[int32]string{
	0: "UnknownTargetType",
	1: "ToSpecificDevice",
	2: "ToSpecificContact",
	3: "ToAllContacts",
	4: "ToSpecificConversation",
	5: "ToSelf",
}

var Event_TargetType_value = map[string]int32{
	"UnknownTargetType":      0,
	"ToSpecificDevice":       1,
	"ToSpecificContact":      2,
	"ToAllContacts":          3,
	"ToSpecificConversation": 4,
	"ToSelf":                 5,
}

func (x Event_TargetType) String() string {
	return proto.EnumName(Event_TargetType_name, int32(x))
}

func (Event_TargetType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a0737e212f090f50, []int{0, 2}
}

type Event_Direction int32

const (
	Event_UnknownDirection Event_Direction = 0
	// Incoming is the value for events created by peers, should be set by the destination when receiving an event.
	Event_Incoming Event_Direction = 1
	// Outgoing is the value for locally-created events, should be set by the source when creating an event.
	Event_Outgoing Event_Direction = 2
	// Node is the value for local events, see ./core/api/node/kind.proto.
	Event_Node Event_Direction = 99
)

var Event_Direction_name = map[int32]string{
	0:  "UnknownDirection",
	1:  "Incoming",
	2:  "Outgoing",
	99: "Node",
}

var Event_Direction_value = map[string]int32{
	"UnknownDirection": 0,
	"Incoming":         1,
	"Outgoing":         2,
	"Node":             99,
}

func (x Event_Direction) String() string {
	return proto.EnumName(Event_Direction_name, int32(x))
}

func (Event_Direction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a0737e212f090f50, []int{0, 3}
}

type EventDispatch_Medium int32

const (
	EventDispatch_UnknownMedium EventDispatch_Medium = 0
	EventDispatch_LocalNetwork  EventDispatch_Medium = 1
	EventDispatch_BLE           EventDispatch_Medium = 2
	EventDispatch_Relay         EventDispatch_Medium = 3
)

var EventDispatch_Medium_name = map[int32]string{
	0: "UnknownMedium",
	1: "LocalNetwork",
	2: "BLE",
	3: "Relay",
}

var EventDispatch_Medium_value = map[string]int32{
	"UnknownMedium": 0,
	"LocalNetwork":  1,
	"BLE":           2,
	"Relay":         3,
}

func (x EventDispatch_Medium) String() string {
	return proto.EnumName(EventDispatch_Medium_name, int32(x))
}

func (EventDispatch_Medium) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a0737e212f090f50, []int{1, 0}
}

type Event struct {
	// ID is a unique ID generated by the event creator.
	// This field is required by gorm.
	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" gorm:"primary_key"`
	// SourceDeviceID is the ID of the source's device.
	// this field is a member of the composite primary key to avoid id collisions.
	SourceDeviceID string `protobuf:"bytes,2,opt,name=source_device_id,json=sourceDeviceId,proto3" json:"source_device_id,omitempty" gorm:"primary_key"`
	// CreatedAt is set to current date when initializing a new Event object.
	// This field is required by gorm.
	CreatedAt time.Time `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"`
	// UpdatedAt is set to current date each time the object is updated in database.
	// This field is required by gorm.
	UpdatedAt time.Time `protobuf:"bytes,4,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"`
	// SentAt is set to current date just after sending the event.
	SentAt *time.Time `protobuf:"bytes,6,opt,name=sent_at,json=sentAt,proto3,stdtime" json:"sent_at,omitempty"`
	// ReceivedAt is set to current date just after receiving the event.
	ReceivedAt *time.Time `protobuf:"bytes,7,opt,name=received_at,json=receivedAt,proto3,stdtime" json:"received_at,omitempty"`
	// AckedAt is set to current date just after receiving an `Ack` event.
	AckedAt *time.Time `protobuf:"bytes,8,opt,name=acked_at,json=ackedAt,proto3,stdtime" json:"acked_at,omitempty"`
	// Direction is set to Outgoing by the source and to Incoming by the destination.
	Direction Event_Direction `protobuf:"varint,9,opt,name=direction,proto3,enum=berty.entity.Event_Direction" json:"direction,omitempty"`
	// SourceAPIVersion is set by the source when creating the message to be sent.
	// this field can be used;
	//   - by the destination to check for compatibility issues
	//   - by everyone when fetching an old event in database to apply local migrations
	APIVersion uint32 `protobuf:"varint,10,opt,name=api_version,json=apiVersion,proto3" json:"api_version,omitempty"`
	// Kind is an enum defining the event type.
	Kind Kind `protobuf:"varint,13,opt,name=kind,proto3,enum=berty.entity.Kind" json:"kind,omitempty"`
	// Attributes is a nested protobuf message containing per-event-type additional attributes, stored in db.
	Attributes []byte `protobuf:"bytes,14,opt,name=attributes,proto3" json:"attributes,omitempty"`
	// SeenAt is set to the date when the event has been displayed on the user's screen.
	SeenAt *time.Time `protobuf:"bytes,16,opt,name=seen_at,json=seenAt,proto3,stdtime" json:"seen_at,omitempty"`
	// AckStatus is aggregated from the different Dispatch events.
	AckStatus Event_AckStatus `protobuf:"varint,17,opt,name=ack_status,json=ackStatus,proto3,enum=berty.entity.Event_AckStatus" json:"ack_status,omitempty"`
	// Dispatches represent each target's dispatch/sending state.
	// this field should only be set for outgoing events.
	Dispatches []*EventDispatch `protobuf:"bytes,18,rep,name=dispatches,proto3" json:"dispatches,omitempty"`
	// SourceContactID is the ID of the source.
	SourceContactID string `protobuf:"bytes,19,opt,name=source_contact_id,json=sourceContactId,proto3" json:"source_contact_id,omitempty"`
	// TargetType defines the scope of the destination
	TargetType Event_TargetType `protobuf:"varint,20,opt,name=target_type,json=targetType,proto3,enum=berty.entity.Event_TargetType" json:"target_type,omitempty"`
	// TragetAddr can be a contact ID, a conversation ID, a device ID
	TargetAddr string `protobuf:"bytes,21,opt,name=target_addr,json=targetAddr,proto3" json:"target_addr,omitempty"`
	// Metadata represents additional metadata and is not stored in database
	Metadata             []*MetadataKeyValue `protobuf:"bytes,99,rep,name=metadata,proto3" json:"metadata,omitempty" gorm:"-"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Event) GetSourceDeviceID() string {
	if m != nil {
		return m.SourceDeviceID
	}
	return ""
}

func (m *Event) GetCreatedAt() time.Time {
	if m != nil {
		return m.CreatedAt
	}
	return time.Time{}
}

func (m *Event) GetUpdatedAt() time.Time {
	if m != nil {
		return m.UpdatedAt
	}
	return time.Time{}
}

func (m *Event) GetSentAt() *time.Time {
	if m != nil {
		return m.SentAt
	}
	return nil
}

func (m *Event) GetReceivedAt() *time.Time {
	if m != nil {
		return m.ReceivedAt
	}
	return nil
}

func (m *Event) GetAckedAt() *time.Time {
	if m != nil {
		return m.AckedAt
	}
	return nil
}

func (m *Event) GetDirection() Event_Direction {
	if m != nil {
		return m.Direction
	}
	return Event_UnknownDirection
}

func (m *Event) GetAPIVersion() uint32 {
	if m != nil {
		return m.APIVersion
	}
	return 0
}

func (m *Event) GetKind() Kind {
	if m != nil {
		return m.Kind
	}
	return Kind_Unknown
}

func (m *Event) GetAttributes() []byte {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *Event) GetSeenAt() *time.Time {
	if m != nil {
		return m.SeenAt
	}
	return nil
}

func (m *Event) GetAckStatus() Event_AckStatus {
	if m != nil {
		return m.AckStatus
	}
	return Event_UnknownAckStatus
}

func (m *Event) GetDispatches() []*EventDispatch {
	if m != nil {
		return m.Dispatches
	}
	return nil
}

func (m *Event) GetSourceContactID() string {
	if m != nil {
		return m.SourceContactID
	}
	return ""
}

func (m *Event) GetTargetType() Event_TargetType {
	if m != nil {
		return m.TargetType
	}
	return Event_UnknownTargetType
}

func (m *Event) GetTargetAddr() string {
	if m != nil {
		return m.TargetAddr
	}
	return ""
}

func (m *Event) GetMetadata() []*MetadataKeyValue {
	if m != nil {
		return m.Metadata
	}
	return nil
}

// EventDispatch represents one sending of an Event to a specific Device
// The primary key is a composite key of EventID+DeviceID
type EventDispatch struct {
	// EventID is the ID of the event
	EventID string `protobuf:"bytes,1,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty" gorm:"primary_key"`
	// DeviceID is the ID of the destination device
	DeviceID string `protobuf:"bytes,2,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty" gorm:"primary_key"`
	// ContactID is the ID of the destination contact
	ContactID string `protobuf:"bytes,3,opt,name=contact_id,json=contactId,proto3" json:"contact_id,omitempty"`
	// SentAt is set to current date when sending the Dispatch.
	SentAt *time.Time `protobuf:"bytes,4,opt,name=sent_at,json=sentAt,proto3,stdtime" json:"sent_at,omitempty"`
	// AckedAt is set to current date just after receiving a `Ack` event.
	AckedAt *time.Time `protobuf:"bytes,5,opt,name=acked_at,json=ackedAt,proto3,stdtime" json:"acked_at,omitempty"`
	// SeenAt is set to the date when the event has been displayed on the user's screen
	SeenAt *time.Time `protobuf:"bytes,6,opt,name=seen_at,json=seenAt,proto3,stdtime" json:"seen_at,omitempty"`
	// AckMedium is the communication medium used when receiving an Ack event
	AckMedium EventDispatch_Medium `protobuf:"varint,7,opt,name=ack_medium,json=ackMedium,proto3,enum=berty.entity.EventDispatch_Medium" json:"ack_medium,omitempty"`
	// SeenMedium is the communication medium used when receiving a Seen event
	SeenMedium           EventDispatch_Medium `protobuf:"varint,8,opt,name=seen_medium,json=seenMedium,proto3,enum=berty.entity.EventDispatch_Medium" json:"seen_medium,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_EventDispatch proto.InternalMessageInfo

func (m *EventDispatch) GetEventID() string {
	if m != nil {
		return m.EventID
	}
	return ""
}

func (m *EventDispatch) GetDeviceID() string {
	if m != nil {
		return m.DeviceID
	}
	return ""
}

func (m *EventDispatch) GetContactID() string {
	if m != nil {
		return m.ContactID
	}
	return ""
}

func (m *EventDispatch) GetSentAt() *time.Time {
	if m != nil {
		return m.SentAt
	}
	return nil
}

func (m *EventDispatch) GetAckedAt() *time.Time {
	if m != nil {
		return m.AckedAt
	}
	return nil
}

func (m *EventDispatch) GetSeenAt() *time.Time {
	if m != nil {
		return m.SeenAt
	}
	return nil
}

func (m *EventDispatch) GetAckMedium() EventDispatch_Medium {
	if m != nil {
		return m.AckMedium
	}
	return EventDispatch_UnknownMedium
}

func (m *EventDispatch) GetSeenMedium() EventDispatch_Medium {
	if m != nil {
		return m.SeenMedium
	}
	return EventDispatch_UnknownMedium
}

type MetadataKeyValue struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Values               []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MetadataKeyValue proto.InternalMessageInfo

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

func (m *MetadataKeyValue) GetValues() []string {
	if m != nil {
		return m.Values
	}
	return nil
}

func init() {
	proto.RegisterEnum("berty.entity.Event_AckStatus", Event_AckStatus_name, Event_AckStatus_value)
	proto.RegisterEnum("berty.entity.Event_SeenStatus", Event_SeenStatus_name, Event_SeenStatus_value)
	proto.RegisterEnum("berty.entity.Event_TargetType", Event_TargetType_name, Event_TargetType_value)
	proto.RegisterEnum("berty.entity.Event_Direction", Event_Direction_name, Event_Direction_value)
	proto.RegisterEnum("berty.entity.EventDispatch_Medium", EventDispatch_Medium_name, EventDispatch_Medium_value)
	proto.RegisterType((*Event)(nil), "berty.entity.Event")
	proto.RegisterType((*EventDispatch)(nil), "berty.entity.EventDispatch")
	proto.RegisterType((*MetadataKeyValue)(nil), "berty.entity.MetadataKeyValue")
}

func init() { proto.RegisterFile("entity/event.proto", fileDescriptor_a0737e212f090f50) }

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

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

func (m *Event) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.ID)))
		i += copy(dAtA[i:], m.ID)
	}
	if len(m.SourceDeviceID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.SourceDeviceID)))
		i += copy(dAtA[i:], m.SourceDeviceID)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
	n1, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	dAtA[i] = 0x22
	i++
	i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
	n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	if m.SentAt != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.SentAt)))
		n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SentAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.ReceivedAt != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.ReceivedAt)))
		n4, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.ReceivedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.AckedAt != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.AckedAt)))
		n5, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.AckedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.Direction != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.Direction))
	}
	if m.APIVersion != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.APIVersion))
	}
	if m.Kind != 0 {
		dAtA[i] = 0x68
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.Kind))
	}
	if len(m.Attributes) > 0 {
		dAtA[i] = 0x72
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Attributes)))
		i += copy(dAtA[i:], m.Attributes)
	}
	if m.SeenAt != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.SeenAt)))
		n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SeenAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.AckStatus != 0 {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.AckStatus))
	}
	if len(m.Dispatches) > 0 {
		for _, msg := range m.Dispatches {
			dAtA[i] = 0x92
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintEvent(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.SourceContactID) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.SourceContactID)))
		i += copy(dAtA[i:], m.SourceContactID)
	}
	if m.TargetType != 0 {
		dAtA[i] = 0xa0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.TargetType))
	}
	if len(m.TargetAddr) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.TargetAddr)))
		i += copy(dAtA[i:], m.TargetAddr)
	}
	if len(m.Metadata) > 0 {
		for _, msg := range m.Metadata {
			dAtA[i] = 0x9a
			i++
			dAtA[i] = 0x6
			i++
			i = encodeVarintEvent(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *EventDispatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.EventID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.EventID)))
		i += copy(dAtA[i:], m.EventID)
	}
	if len(m.DeviceID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.DeviceID)))
		i += copy(dAtA[i:], m.DeviceID)
	}
	if len(m.ContactID) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.ContactID)))
		i += copy(dAtA[i:], m.ContactID)
	}
	if m.SentAt != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.SentAt)))
		n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SentAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.AckedAt != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.AckedAt)))
		n8, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.AckedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.SeenAt != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.SeenAt)))
		n9, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SeenAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.AckMedium != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.AckMedium))
	}
	if m.SeenMedium != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.SeenMedium))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *MetadataKeyValue) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Values) > 0 {
		for _, s := range m.Values {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintEvent(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.SourceDeviceID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovEvent(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
	n += 1 + l + sovEvent(uint64(l))
	if m.SentAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.SentAt)
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.ReceivedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.ReceivedAt)
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.AckedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.AckedAt)
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.Direction != 0 {
		n += 1 + sovEvent(uint64(m.Direction))
	}
	if m.APIVersion != 0 {
		n += 1 + sovEvent(uint64(m.APIVersion))
	}
	if m.Kind != 0 {
		n += 1 + sovEvent(uint64(m.Kind))
	}
	l = len(m.Attributes)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.SeenAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.SeenAt)
		n += 2 + l + sovEvent(uint64(l))
	}
	if m.AckStatus != 0 {
		n += 2 + sovEvent(uint64(m.AckStatus))
	}
	if len(m.Dispatches) > 0 {
		for _, e := range m.Dispatches {
			l = e.Size()
			n += 2 + l + sovEvent(uint64(l))
		}
	}
	l = len(m.SourceContactID)
	if l > 0 {
		n += 2 + l + sovEvent(uint64(l))
	}
	if m.TargetType != 0 {
		n += 2 + sovEvent(uint64(m.TargetType))
	}
	l = len(m.TargetAddr)
	if l > 0 {
		n += 2 + l + sovEvent(uint64(l))
	}
	if len(m.Metadata) > 0 {
		for _, e := range m.Metadata {
			l = e.Size()
			n += 2 + l + sovEvent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EventDispatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.EventID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.DeviceID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.ContactID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.SentAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.SentAt)
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.AckedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.AckedAt)
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.SeenAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.SeenAt)
		n += 1 + l + sovEvent(uint64(l))
	}
	if m.AckMedium != 0 {
		n += 1 + sovEvent(uint64(m.AckMedium))
	}
	if m.SeenMedium != 0 {
		n += 1 + sovEvent(uint64(m.SeenMedium))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovEvent(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozEvent(x uint64) (n int) {
	return sovEvent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Event) 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 ErrIntOverflowEvent
			}
			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: Event: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceDeviceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceDeviceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SentAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SentAt == nil {
				m.SentAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.SentAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceivedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReceivedAt == nil {
				m.ReceivedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.ReceivedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AckedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AckedAt == nil {
				m.AckedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.AckedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType)
			}
			m.Direction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Direction |= (Event_Direction(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
			}
			m.APIVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.APIVersion |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			m.Kind = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Kind |= (Kind(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attributes = append(m.Attributes[:0], dAtA[iNdEx:postIndex]...)
			if m.Attributes == nil {
				m.Attributes = []byte{}
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeenAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SeenAt == nil {
				m.SeenAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.SeenAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AckStatus", wireType)
			}
			m.AckStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AckStatus |= (Event_AckStatus(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dispatches", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dispatches = append(m.Dispatches, &EventDispatch{})
			if err := m.Dispatches[len(m.Dispatches)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceContactID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceContactID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetType", wireType)
			}
			m.TargetType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetType |= (Event_TargetType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 99:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata, &MetadataKeyValue{})
			if err := m.Metadata[len(m.Metadata)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventDispatch) 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 ErrIntOverflowEvent
			}
			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: EventDispatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventDispatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContactID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContactID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SentAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SentAt == nil {
				m.SentAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.SentAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AckedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AckedAt == nil {
				m.AckedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.AckedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeenAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SeenAt == nil {
				m.SeenAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.SeenAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AckMedium", wireType)
			}
			m.AckMedium = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AckMedium |= (EventDispatch_Medium(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeenMedium", wireType)
			}
			m.SeenMedium = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SeenMedium |= (EventDispatch_Medium(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetadataKeyValue) 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 ErrIntOverflowEvent
			}
			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: MetadataKeyValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataKeyValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEvent(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowEvent
			}
			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, ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthEvent
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowEvent
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipEvent(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthEvent = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvent   = fmt.Errorf("proto: integer overflow")
)