// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pb/protos/events.proto

package pb

import (
	fmt "fmt"
	model "github.com/anyproto/anytype-heart/pkg/lib/pb/model"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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

type EventBlockDataviewSliceOperation int32

const (
	EventBlockDataview_SliceOperationNone    EventBlockDataviewSliceOperation = 0
	EventBlockDataview_SliceOperationAdd     EventBlockDataviewSliceOperation = 1
	EventBlockDataview_SliceOperationMove    EventBlockDataviewSliceOperation = 2
	EventBlockDataview_SliceOperationRemove  EventBlockDataviewSliceOperation = 3
	EventBlockDataview_SliceOperationReplace EventBlockDataviewSliceOperation = 4
)

var EventBlockDataviewSliceOperation_name = map[int32]string{
	0: "SliceOperationNone",
	1: "SliceOperationAdd",
	2: "SliceOperationMove",
	3: "SliceOperationRemove",
	4: "SliceOperationReplace",
}

var EventBlockDataviewSliceOperation_value = map[string]int32{
	"SliceOperationNone":    0,
	"SliceOperationAdd":     1,
	"SliceOperationMove":    2,
	"SliceOperationRemove":  3,
	"SliceOperationReplace": 4,
}

func (x EventBlockDataviewSliceOperation) String() string {
	return proto.EnumName(EventBlockDataviewSliceOperation_name, int32(x))
}

func (EventBlockDataviewSliceOperation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{0, 4, 6, 0}
}

type EventStatusThreadSyncStatus int32

const (
	EventStatusThread_Unknown             EventStatusThreadSyncStatus = 0
	EventStatusThread_Offline             EventStatusThreadSyncStatus = 1
	EventStatusThread_Syncing             EventStatusThreadSyncStatus = 2
	EventStatusThread_Synced              EventStatusThreadSyncStatus = 3
	EventStatusThread_Failed              EventStatusThreadSyncStatus = 4
	EventStatusThread_IncompatibleVersion EventStatusThreadSyncStatus = 5
	EventStatusThread_NetworkNeedsUpdate  EventStatusThreadSyncStatus = 6
)

var EventStatusThreadSyncStatus_name = map[int32]string{
	0: "Unknown",
	1: "Offline",
	2: "Syncing",
	3: "Synced",
	4: "Failed",
	5: "IncompatibleVersion",
	6: "NetworkNeedsUpdate",
}

var EventStatusThreadSyncStatus_value = map[string]int32{
	"Unknown":             0,
	"Offline":             1,
	"Syncing":             2,
	"Synced":              3,
	"Failed":              4,
	"IncompatibleVersion": 5,
	"NetworkNeedsUpdate":  6,
}

func (x EventStatusThreadSyncStatus) String() string {
	return proto.EnumName(EventStatusThreadSyncStatus_name, int32(x))
}

func (EventStatusThreadSyncStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{0, 8, 0, 0}
}

type EventSpaceStatus int32

const (
	EventSpace_Synced             EventSpaceStatus = 0
	EventSpace_Syncing            EventSpaceStatus = 1
	EventSpace_Error              EventSpaceStatus = 2
	EventSpace_Offline            EventSpaceStatus = 3
	EventSpace_NetworkNeedsUpdate EventSpaceStatus = 4
)

var EventSpaceStatus_name = map[int32]string{
	0: "Synced",
	1: "Syncing",
	2: "Error",
	3: "Offline",
	4: "NetworkNeedsUpdate",
}

var EventSpaceStatus_value = map[string]int32{
	"Synced":             0,
	"Syncing":            1,
	"Error":              2,
	"Offline":            3,
	"NetworkNeedsUpdate": 4,
}

func (x EventSpaceStatus) String() string {
	return proto.EnumName(EventSpaceStatus_name, int32(x))
}

func (EventSpaceStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{0, 13, 0}
}

type EventSpaceNetwork int32

const (
	EventSpace_Anytype   EventSpaceNetwork = 0
	EventSpace_SelfHost  EventSpaceNetwork = 1
	EventSpace_LocalOnly EventSpaceNetwork = 2
)

var EventSpaceNetwork_name = map[int32]string{
	0: "Anytype",
	1: "SelfHost",
	2: "LocalOnly",
}

var EventSpaceNetwork_value = map[string]int32{
	"Anytype":   0,
	"SelfHost":  1,
	"LocalOnly": 2,
}

func (x EventSpaceNetwork) String() string {
	return proto.EnumName(EventSpaceNetwork_name, int32(x))
}

func (EventSpaceNetwork) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{0, 13, 1}
}

type EventSpaceSyncError int32

const (
	EventSpace_Null                EventSpaceSyncError = 0
	EventSpace_StorageLimitExceed  EventSpaceSyncError = 1
	EventSpace_IncompatibleVersion EventSpaceSyncError = 2
	EventSpace_NetworkError        EventSpaceSyncError = 3
)

var EventSpaceSyncError_name = map[int32]string{
	0: "Null",
	1: "StorageLimitExceed",
	2: "IncompatibleVersion",
	3: "NetworkError",
}

var EventSpaceSyncError_value = map[string]int32{
	"Null":                0,
	"StorageLimitExceed":  1,
	"IncompatibleVersion": 2,
	"NetworkError":        3,
}

func (x EventSpaceSyncError) String() string {
	return proto.EnumName(EventSpaceSyncError_name, int32(x))
}

func (EventSpaceSyncError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{0, 13, 2}
}

type EventP2PStatusStatus int32

const (
	EventP2PStatus_NotConnected EventP2PStatusStatus = 0
	EventP2PStatus_NotPossible  EventP2PStatusStatus = 1
	EventP2PStatus_Connected    EventP2PStatusStatus = 2
	EventP2PStatus_Restricted   EventP2PStatusStatus = 3
)

var EventP2PStatusStatus_name = map[int32]string{
	0: "NotConnected",
	1: "NotPossible",
	2: "Connected",
	3: "Restricted",
}

var EventP2PStatusStatus_value = map[string]int32{
	"NotConnected": 0,
	"NotPossible":  1,
	"Connected":    2,
	"Restricted":   3,
}

func (x EventP2PStatusStatus) String() string {
	return proto.EnumName(EventP2PStatusStatus_name, int32(x))
}

func (EventP2PStatusStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{0, 14, 0}
}

type ModelProcessState int32

const (
	ModelProcess_None     ModelProcessState = 0
	ModelProcess_Running  ModelProcessState = 1
	ModelProcess_Done     ModelProcessState = 2
	ModelProcess_Canceled ModelProcessState = 3
	ModelProcess_Error    ModelProcessState = 4
)

var ModelProcessState_name = map[int32]string{
	0: "None",
	1: "Running",
	2: "Done",
	3: "Canceled",
	4: "Error",
}

var ModelProcessState_value = map[string]int32{
	"None":     0,
	"Running":  1,
	"Done":     2,
	"Canceled": 3,
	"Error":    4,
}

func (x ModelProcessState) String() string {
	return proto.EnumName(ModelProcessState_name, int32(x))
}

func (ModelProcessState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a966342d378ae5f5, []int{2, 0, 0}
}

// Event – type of message, that could be sent from a middleware to the
// corresponding front-end.
type Event struct {
	Messages  []*EventMessage `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"`
	ContextId string          `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Initiator *model.Account  `protobuf:"bytes,3,opt,name=initiator,proto3" json:"initiator,omitempty"`
	TraceId   string          `protobuf:"bytes,4,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

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_a966342d378ae5f5, []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.MarshalToSizedBuffer(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) GetMessages() []*EventMessage {
	if m != nil {
		return m.Messages
	}
	return nil
}

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

func (m *Event) GetInitiator() *model.Account {
	if m != nil {
		return m.Initiator
	}
	return nil
}

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

type EventMessage struct {
	SpaceId string `protobuf:"bytes,132,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*EventMessageValueOfAccountShow
	//	*EventMessageValueOfAccountDetails
	//	*EventMessageValueOfAccountConfigUpdate
	//	*EventMessageValueOfAccountUpdate
	//	*EventMessageValueOfAccountLinkChallenge
	//	*EventMessageValueOfAccountLinkChallengeHide
	//	*EventMessageValueOfObjectDetailsSet
	//	*EventMessageValueOfObjectDetailsAmend
	//	*EventMessageValueOfObjectDetailsUnset
	//	*EventMessageValueOfObjectRelationsAmend
	//	*EventMessageValueOfObjectRelationsRemove
	//	*EventMessageValueOfObjectRemove
	//	*EventMessageValueOfObjectClose
	//	*EventMessageValueOfObjectRestrictionsSet
	//	*EventMessageValueOfSubscriptionAdd
	//	*EventMessageValueOfSubscriptionRemove
	//	*EventMessageValueOfSubscriptionPosition
	//	*EventMessageValueOfSubscriptionCounters
	//	*EventMessageValueOfSubscriptionGroups
	//	*EventMessageValueOfBlockAdd
	//	*EventMessageValueOfBlockDelete
	//	*EventMessageValueOfFilesUpload
	//	*EventMessageValueOfMarksInfo
	//	*EventMessageValueOfBlockSetFields
	//	*EventMessageValueOfBlockSetChildrenIds
	//	*EventMessageValueOfBlockSetRestrictions
	//	*EventMessageValueOfBlockSetBackgroundColor
	//	*EventMessageValueOfBlockSetText
	//	*EventMessageValueOfBlockSetFile
	//	*EventMessageValueOfBlockSetLink
	//	*EventMessageValueOfBlockSetBookmark
	//	*EventMessageValueOfBlockSetAlign
	//	*EventMessageValueOfBlockSetDiv
	//	*EventMessageValueOfBlockSetRelation
	//	*EventMessageValueOfBlockSetLatex
	//	*EventMessageValueOfBlockSetVerticalAlign
	//	*EventMessageValueOfBlockSetTableRow
	//	*EventMessageValueOfBlockSetWidget
	//	*EventMessageValueOfBlockDataviewViewSet
	//	*EventMessageValueOfBlockDataviewViewDelete
	//	*EventMessageValueOfBlockDataviewViewOrder
	//	*EventMessageValueOfBlockDataviewSourceSet
	//	*EventMessageValueOfBlockDataViewGroupOrderUpdate
	//	*EventMessageValueOfBlockDataViewObjectOrderUpdate
	//	*EventMessageValueOfBlockDataviewRelationDelete
	//	*EventMessageValueOfBlockDataviewRelationSet
	//	*EventMessageValueOfBlockDataviewViewUpdate
	//	*EventMessageValueOfBlockDataviewTargetObjectIdSet
	//	*EventMessageValueOfBlockDataviewIsCollectionSet
	//	*EventMessageValueOfBlockDataviewOldRelationDelete
	//	*EventMessageValueOfBlockDataviewOldRelationSet
	//	*EventMessageValueOfUserBlockJoin
	//	*EventMessageValueOfUserBlockLeft
	//	*EventMessageValueOfUserBlockSelectRange
	//	*EventMessageValueOfUserBlockTextRange
	//	*EventMessageValueOfPing
	//	*EventMessageValueOfProcessNew
	//	*EventMessageValueOfProcessUpdate
	//	*EventMessageValueOfProcessDone
	//	*EventMessageValueOfThreadStatus
	//	*EventMessageValueOfFileLimitReached
	//	*EventMessageValueOfFileSpaceUsage
	//	*EventMessageValueOfFileLocalUsage
	//	*EventMessageValueOfFileLimitUpdated
	//	*EventMessageValueOfNotificationSend
	//	*EventMessageValueOfNotificationUpdate
	//	*EventMessageValueOfPayloadBroadcast
	//	*EventMessageValueOfMembershipUpdate
	//	*EventMessageValueOfSpaceSyncStatusUpdate
	//	*EventMessageValueOfP2PStatusUpdate
	//	*EventMessageValueOfImportFinish
	//	*EventMessageValueOfChatAdd
	//	*EventMessageValueOfChatUpdate
	//	*EventMessageValueOfChatUpdateReactions
	//	*EventMessageValueOfChatUpdateMessageReadStatus
	//	*EventMessageValueOfChatUpdateMentionReadStatus
	//	*EventMessageValueOfChatUpdateMessageSyncStatus
	//	*EventMessageValueOfChatDelete
	//	*EventMessageValueOfChatStateUpdate
	Value IsEventMessageValue `protobuf_oneof:"value"`
}

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

var xxx_messageInfo_EventMessage proto.InternalMessageInfo

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

type EventMessageValueOfAccountShow struct {
	AccountShow *EventAccountShow `protobuf:"bytes,1,opt,name=accountShow,proto3,oneof" json:"accountShow,omitempty"`
}
type EventMessageValueOfAccountDetails struct {
	AccountDetails *EventAccountDetails `protobuf:"bytes,201,opt,name=accountDetails,proto3,oneof" json:"accountDetails,omitempty"`
}
type EventMessageValueOfAccountConfigUpdate struct {
	AccountConfigUpdate *EventAccountConfigUpdate `protobuf:"bytes,202,opt,name=accountConfigUpdate,proto3,oneof" json:"accountConfigUpdate,omitempty"`
}
type EventMessageValueOfAccountUpdate struct {
	AccountUpdate *EventAccountUpdate `protobuf:"bytes,203,opt,name=accountUpdate,proto3,oneof" json:"accountUpdate,omitempty"`
}
type EventMessageValueOfAccountLinkChallenge struct {
	AccountLinkChallenge *EventAccountLinkChallenge `protobuf:"bytes,204,opt,name=accountLinkChallenge,proto3,oneof" json:"accountLinkChallenge,omitempty"`
}
type EventMessageValueOfAccountLinkChallengeHide struct {
	AccountLinkChallengeHide *EventAccountLinkChallengeHide `protobuf:"bytes,205,opt,name=accountLinkChallengeHide,proto3,oneof" json:"accountLinkChallengeHide,omitempty"`
}
type EventMessageValueOfObjectDetailsSet struct {
	ObjectDetailsSet *EventObjectDetailsSet `protobuf:"bytes,16,opt,name=objectDetailsSet,proto3,oneof" json:"objectDetailsSet,omitempty"`
}
type EventMessageValueOfObjectDetailsAmend struct {
	ObjectDetailsAmend *EventObjectDetailsAmend `protobuf:"bytes,50,opt,name=objectDetailsAmend,proto3,oneof" json:"objectDetailsAmend,omitempty"`
}
type EventMessageValueOfObjectDetailsUnset struct {
	ObjectDetailsUnset *EventObjectDetailsUnset `protobuf:"bytes,51,opt,name=objectDetailsUnset,proto3,oneof" json:"objectDetailsUnset,omitempty"`
}
type EventMessageValueOfObjectRelationsAmend struct {
	ObjectRelationsAmend *EventObjectRelationsAmend `protobuf:"bytes,52,opt,name=objectRelationsAmend,proto3,oneof" json:"objectRelationsAmend,omitempty"`
}
type EventMessageValueOfObjectRelationsRemove struct {
	ObjectRelationsRemove *EventObjectRelationsRemove `protobuf:"bytes,53,opt,name=objectRelationsRemove,proto3,oneof" json:"objectRelationsRemove,omitempty"`
}
type EventMessageValueOfObjectRemove struct {
	ObjectRemove *EventObjectRemove `protobuf:"bytes,54,opt,name=objectRemove,proto3,oneof" json:"objectRemove,omitempty"`
}
type EventMessageValueOfObjectClose struct {
	ObjectClose *EventObjectClose `protobuf:"bytes,65,opt,name=objectClose,proto3,oneof" json:"objectClose,omitempty"`
}
type EventMessageValueOfObjectRestrictionsSet struct {
	ObjectRestrictionsSet *EventObjectRestrictionsSet `protobuf:"bytes,55,opt,name=objectRestrictionsSet,proto3,oneof" json:"objectRestrictionsSet,omitempty"`
}
type EventMessageValueOfSubscriptionAdd struct {
	SubscriptionAdd *EventObjectSubscriptionAdd `protobuf:"bytes,60,opt,name=subscriptionAdd,proto3,oneof" json:"subscriptionAdd,omitempty"`
}
type EventMessageValueOfSubscriptionRemove struct {
	SubscriptionRemove *EventObjectSubscriptionRemove `protobuf:"bytes,61,opt,name=subscriptionRemove,proto3,oneof" json:"subscriptionRemove,omitempty"`
}
type EventMessageValueOfSubscriptionPosition struct {
	SubscriptionPosition *EventObjectSubscriptionPosition `protobuf:"bytes,62,opt,name=subscriptionPosition,proto3,oneof" json:"subscriptionPosition,omitempty"`
}
type EventMessageValueOfSubscriptionCounters struct {
	SubscriptionCounters *EventObjectSubscriptionCounters `protobuf:"bytes,63,opt,name=subscriptionCounters,proto3,oneof" json:"subscriptionCounters,omitempty"`
}
type EventMessageValueOfSubscriptionGroups struct {
	SubscriptionGroups *EventObjectSubscriptionGroups `protobuf:"bytes,64,opt,name=subscriptionGroups,proto3,oneof" json:"subscriptionGroups,omitempty"`
}
type EventMessageValueOfBlockAdd struct {
	BlockAdd *EventBlockAdd `protobuf:"bytes,2,opt,name=blockAdd,proto3,oneof" json:"blockAdd,omitempty"`
}
type EventMessageValueOfBlockDelete struct {
	BlockDelete *EventBlockDelete `protobuf:"bytes,3,opt,name=blockDelete,proto3,oneof" json:"blockDelete,omitempty"`
}
type EventMessageValueOfFilesUpload struct {
	FilesUpload *EventBlockFilesUpload `protobuf:"bytes,4,opt,name=filesUpload,proto3,oneof" json:"filesUpload,omitempty"`
}
type EventMessageValueOfMarksInfo struct {
	MarksInfo *EventBlockMarksInfo `protobuf:"bytes,5,opt,name=marksInfo,proto3,oneof" json:"marksInfo,omitempty"`
}
type EventMessageValueOfBlockSetFields struct {
	BlockSetFields *EventBlockSetFields `protobuf:"bytes,6,opt,name=blockSetFields,proto3,oneof" json:"blockSetFields,omitempty"`
}
type EventMessageValueOfBlockSetChildrenIds struct {
	BlockSetChildrenIds *EventBlockSetChildrenIds `protobuf:"bytes,7,opt,name=blockSetChildrenIds,proto3,oneof" json:"blockSetChildrenIds,omitempty"`
}
type EventMessageValueOfBlockSetRestrictions struct {
	BlockSetRestrictions *EventBlockSetRestrictions `protobuf:"bytes,8,opt,name=blockSetRestrictions,proto3,oneof" json:"blockSetRestrictions,omitempty"`
}
type EventMessageValueOfBlockSetBackgroundColor struct {
	BlockSetBackgroundColor *EventBlockSetBackgroundColor `protobuf:"bytes,9,opt,name=blockSetBackgroundColor,proto3,oneof" json:"blockSetBackgroundColor,omitempty"`
}
type EventMessageValueOfBlockSetText struct {
	BlockSetText *EventBlockSetText `protobuf:"bytes,10,opt,name=blockSetText,proto3,oneof" json:"blockSetText,omitempty"`
}
type EventMessageValueOfBlockSetFile struct {
	BlockSetFile *EventBlockSetFile `protobuf:"bytes,11,opt,name=blockSetFile,proto3,oneof" json:"blockSetFile,omitempty"`
}
type EventMessageValueOfBlockSetLink struct {
	BlockSetLink *EventBlockSetLink `protobuf:"bytes,13,opt,name=blockSetLink,proto3,oneof" json:"blockSetLink,omitempty"`
}
type EventMessageValueOfBlockSetBookmark struct {
	BlockSetBookmark *EventBlockSetBookmark `protobuf:"bytes,14,opt,name=blockSetBookmark,proto3,oneof" json:"blockSetBookmark,omitempty"`
}
type EventMessageValueOfBlockSetAlign struct {
	BlockSetAlign *EventBlockSetAlign `protobuf:"bytes,15,opt,name=blockSetAlign,proto3,oneof" json:"blockSetAlign,omitempty"`
}
type EventMessageValueOfBlockSetDiv struct {
	BlockSetDiv *EventBlockSetDiv `protobuf:"bytes,17,opt,name=blockSetDiv,proto3,oneof" json:"blockSetDiv,omitempty"`
}
type EventMessageValueOfBlockSetRelation struct {
	BlockSetRelation *EventBlockSetRelation `protobuf:"bytes,21,opt,name=blockSetRelation,proto3,oneof" json:"blockSetRelation,omitempty"`
}
type EventMessageValueOfBlockSetLatex struct {
	BlockSetLatex *EventBlockSetLatex `protobuf:"bytes,25,opt,name=blockSetLatex,proto3,oneof" json:"blockSetLatex,omitempty"`
}
type EventMessageValueOfBlockSetVerticalAlign struct {
	BlockSetVerticalAlign *EventBlockSetVerticalAlign `protobuf:"bytes,36,opt,name=blockSetVerticalAlign,proto3,oneof" json:"blockSetVerticalAlign,omitempty"`
}
type EventMessageValueOfBlockSetTableRow struct {
	BlockSetTableRow *EventBlockSetTableRow `protobuf:"bytes,37,opt,name=blockSetTableRow,proto3,oneof" json:"blockSetTableRow,omitempty"`
}
type EventMessageValueOfBlockSetWidget struct {
	BlockSetWidget *EventBlockSetWidget `protobuf:"bytes,40,opt,name=blockSetWidget,proto3,oneof" json:"blockSetWidget,omitempty"`
}
type EventMessageValueOfBlockDataviewViewSet struct {
	BlockDataviewViewSet *EventBlockDataviewViewSet `protobuf:"bytes,19,opt,name=blockDataviewViewSet,proto3,oneof" json:"blockDataviewViewSet,omitempty"`
}
type EventMessageValueOfBlockDataviewViewDelete struct {
	BlockDataviewViewDelete *EventBlockDataviewViewDelete `protobuf:"bytes,20,opt,name=blockDataviewViewDelete,proto3,oneof" json:"blockDataviewViewDelete,omitempty"`
}
type EventMessageValueOfBlockDataviewViewOrder struct {
	BlockDataviewViewOrder *EventBlockDataviewViewOrder `protobuf:"bytes,29,opt,name=blockDataviewViewOrder,proto3,oneof" json:"blockDataviewViewOrder,omitempty"`
}
type EventMessageValueOfBlockDataviewSourceSet struct {
	BlockDataviewSourceSet *EventBlockDataviewSourceSet `protobuf:"bytes,35,opt,name=blockDataviewSourceSet,proto3,oneof" json:"blockDataviewSourceSet,omitempty"`
}
type EventMessageValueOfBlockDataViewGroupOrderUpdate struct {
	BlockDataViewGroupOrderUpdate *EventBlockDataviewGroupOrderUpdate `protobuf:"bytes,38,opt,name=blockDataViewGroupOrderUpdate,proto3,oneof" json:"blockDataViewGroupOrderUpdate,omitempty"`
}
type EventMessageValueOfBlockDataViewObjectOrderUpdate struct {
	BlockDataViewObjectOrderUpdate *EventBlockDataviewObjectOrderUpdate `protobuf:"bytes,39,opt,name=blockDataViewObjectOrderUpdate,proto3,oneof" json:"blockDataViewObjectOrderUpdate,omitempty"`
}
type EventMessageValueOfBlockDataviewRelationDelete struct {
	BlockDataviewRelationDelete *EventBlockDataviewRelationDelete `protobuf:"bytes,124,opt,name=blockDataviewRelationDelete,proto3,oneof" json:"blockDataviewRelationDelete,omitempty"`
}
type EventMessageValueOfBlockDataviewRelationSet struct {
	BlockDataviewRelationSet *EventBlockDataviewRelationSet `protobuf:"bytes,123,opt,name=blockDataviewRelationSet,proto3,oneof" json:"blockDataviewRelationSet,omitempty"`
}
type EventMessageValueOfBlockDataviewViewUpdate struct {
	BlockDataviewViewUpdate *EventBlockDataviewViewUpdate `protobuf:"bytes,125,opt,name=blockDataviewViewUpdate,proto3,oneof" json:"blockDataviewViewUpdate,omitempty"`
}
type EventMessageValueOfBlockDataviewTargetObjectIdSet struct {
	BlockDataviewTargetObjectIdSet *EventBlockDataviewTargetObjectIdSet `protobuf:"bytes,126,opt,name=blockDataviewTargetObjectIdSet,proto3,oneof" json:"blockDataviewTargetObjectIdSet,omitempty"`
}
type EventMessageValueOfBlockDataviewIsCollectionSet struct {
	BlockDataviewIsCollectionSet *EventBlockDataviewIsCollectionSet `protobuf:"bytes,127,opt,name=blockDataviewIsCollectionSet,proto3,oneof" json:"blockDataviewIsCollectionSet,omitempty"`
}
type EventMessageValueOfBlockDataviewOldRelationDelete struct {
	BlockDataviewOldRelationDelete *EventBlockDataviewOldRelationDelete `protobuf:"bytes,24,opt,name=blockDataviewOldRelationDelete,proto3,oneof" json:"blockDataviewOldRelationDelete,omitempty"`
}
type EventMessageValueOfBlockDataviewOldRelationSet struct {
	BlockDataviewOldRelationSet *EventBlockDataviewOldRelationSet `protobuf:"bytes,23,opt,name=blockDataviewOldRelationSet,proto3,oneof" json:"blockDataviewOldRelationSet,omitempty"`
}
type EventMessageValueOfUserBlockJoin struct {
	UserBlockJoin *EventUserBlockJoin `protobuf:"bytes,31,opt,name=userBlockJoin,proto3,oneof" json:"userBlockJoin,omitempty"`
}
type EventMessageValueOfUserBlockLeft struct {
	UserBlockLeft *EventUserBlockLeft `protobuf:"bytes,32,opt,name=userBlockLeft,proto3,oneof" json:"userBlockLeft,omitempty"`
}
type EventMessageValueOfUserBlockSelectRange struct {
	UserBlockSelectRange *EventUserBlockSelectRange `protobuf:"bytes,33,opt,name=userBlockSelectRange,proto3,oneof" json:"userBlockSelectRange,omitempty"`
}
type EventMessageValueOfUserBlockTextRange struct {
	UserBlockTextRange *EventUserBlockTextRange `protobuf:"bytes,34,opt,name=userBlockTextRange,proto3,oneof" json:"userBlockTextRange,omitempty"`
}
type EventMessageValueOfPing struct {
	Ping *EventPing `protobuf:"bytes,100,opt,name=ping,proto3,oneof" json:"ping,omitempty"`
}
type EventMessageValueOfProcessNew struct {
	ProcessNew *EventProcessNew `protobuf:"bytes,101,opt,name=processNew,proto3,oneof" json:"processNew,omitempty"`
}
type EventMessageValueOfProcessUpdate struct {
	ProcessUpdate *EventProcessUpdate `protobuf:"bytes,102,opt,name=processUpdate,proto3,oneof" json:"processUpdate,omitempty"`
}
type EventMessageValueOfProcessDone struct {
	ProcessDone *EventProcessDone `protobuf:"bytes,103,opt,name=processDone,proto3,oneof" json:"processDone,omitempty"`
}
type EventMessageValueOfThreadStatus struct {
	ThreadStatus *EventStatusThread `protobuf:"bytes,110,opt,name=threadStatus,proto3,oneof" json:"threadStatus,omitempty"`
}
type EventMessageValueOfFileLimitReached struct {
	FileLimitReached *EventFileLimitReached `protobuf:"bytes,111,opt,name=fileLimitReached,proto3,oneof" json:"fileLimitReached,omitempty"`
}
type EventMessageValueOfFileSpaceUsage struct {
	FileSpaceUsage *EventFileSpaceUsage `protobuf:"bytes,112,opt,name=fileSpaceUsage,proto3,oneof" json:"fileSpaceUsage,omitempty"`
}
type EventMessageValueOfFileLocalUsage struct {
	FileLocalUsage *EventFileLocalUsage `protobuf:"bytes,113,opt,name=fileLocalUsage,proto3,oneof" json:"fileLocalUsage,omitempty"`
}
type EventMessageValueOfFileLimitUpdated struct {
	FileLimitUpdated *EventFileLimitUpdated `protobuf:"bytes,118,opt,name=fileLimitUpdated,proto3,oneof" json:"fileLimitUpdated,omitempty"`
}
type EventMessageValueOfNotificationSend struct {
	NotificationSend *EventNotificationSend `protobuf:"bytes,114,opt,name=notificationSend,proto3,oneof" json:"notificationSend,omitempty"`
}
type EventMessageValueOfNotificationUpdate struct {
	NotificationUpdate *EventNotificationUpdate `protobuf:"bytes,115,opt,name=notificationUpdate,proto3,oneof" json:"notificationUpdate,omitempty"`
}
type EventMessageValueOfPayloadBroadcast struct {
	PayloadBroadcast *EventPayloadBroadcast `protobuf:"bytes,116,opt,name=payloadBroadcast,proto3,oneof" json:"payloadBroadcast,omitempty"`
}
type EventMessageValueOfMembershipUpdate struct {
	MembershipUpdate *EventMembershipUpdate `protobuf:"bytes,117,opt,name=membershipUpdate,proto3,oneof" json:"membershipUpdate,omitempty"`
}
type EventMessageValueOfSpaceSyncStatusUpdate struct {
	SpaceSyncStatusUpdate *EventSpaceSyncStatusUpdate `protobuf:"bytes,119,opt,name=spaceSyncStatusUpdate,proto3,oneof" json:"spaceSyncStatusUpdate,omitempty"`
}
type EventMessageValueOfP2PStatusUpdate struct {
	P2PStatusUpdate *EventP2PStatusUpdate `protobuf:"bytes,120,opt,name=p2pStatusUpdate,proto3,oneof" json:"p2pStatusUpdate,omitempty"`
}
type EventMessageValueOfImportFinish struct {
	ImportFinish *EventImportFinish `protobuf:"bytes,121,opt,name=importFinish,proto3,oneof" json:"importFinish,omitempty"`
}
type EventMessageValueOfChatAdd struct {
	ChatAdd *EventChatAdd `protobuf:"bytes,128,opt,name=chatAdd,proto3,oneof" json:"chatAdd,omitempty"`
}
type EventMessageValueOfChatUpdate struct {
	ChatUpdate *EventChatUpdate `protobuf:"bytes,129,opt,name=chatUpdate,proto3,oneof" json:"chatUpdate,omitempty"`
}
type EventMessageValueOfChatUpdateReactions struct {
	ChatUpdateReactions *EventChatUpdateReactions `protobuf:"bytes,130,opt,name=chatUpdateReactions,proto3,oneof" json:"chatUpdateReactions,omitempty"`
}
type EventMessageValueOfChatUpdateMessageReadStatus struct {
	ChatUpdateMessageReadStatus *EventChatUpdateMessageReadStatus `protobuf:"bytes,134,opt,name=chatUpdateMessageReadStatus,proto3,oneof" json:"chatUpdateMessageReadStatus,omitempty"`
}
type EventMessageValueOfChatUpdateMentionReadStatus struct {
	ChatUpdateMentionReadStatus *EventChatUpdateMentionReadStatus `protobuf:"bytes,135,opt,name=chatUpdateMentionReadStatus,proto3,oneof" json:"chatUpdateMentionReadStatus,omitempty"`
}
type EventMessageValueOfChatUpdateMessageSyncStatus struct {
	ChatUpdateMessageSyncStatus *EventChatUpdateMessageSyncStatus `protobuf:"bytes,136,opt,name=chatUpdateMessageSyncStatus,proto3,oneof" json:"chatUpdateMessageSyncStatus,omitempty"`
}
type EventMessageValueOfChatDelete struct {
	ChatDelete *EventChatDelete `protobuf:"bytes,131,opt,name=chatDelete,proto3,oneof" json:"chatDelete,omitempty"`
}
type EventMessageValueOfChatStateUpdate struct {
	ChatStateUpdate *EventChatUpdateState `protobuf:"bytes,133,opt,name=chatStateUpdate,proto3,oneof" json:"chatStateUpdate,omitempty"`
}

func (*EventMessageValueOfAccountShow) IsEventMessageValue()                    {}
func (*EventMessageValueOfAccountDetails) IsEventMessageValue()                 {}
func (*EventMessageValueOfAccountConfigUpdate) IsEventMessageValue()            {}
func (*EventMessageValueOfAccountUpdate) IsEventMessageValue()                  {}
func (*EventMessageValueOfAccountLinkChallenge) IsEventMessageValue()           {}
func (*EventMessageValueOfAccountLinkChallengeHide) IsEventMessageValue()       {}
func (*EventMessageValueOfObjectDetailsSet) IsEventMessageValue()               {}
func (*EventMessageValueOfObjectDetailsAmend) IsEventMessageValue()             {}
func (*EventMessageValueOfObjectDetailsUnset) IsEventMessageValue()             {}
func (*EventMessageValueOfObjectRelationsAmend) IsEventMessageValue()           {}
func (*EventMessageValueOfObjectRelationsRemove) IsEventMessageValue()          {}
func (*EventMessageValueOfObjectRemove) IsEventMessageValue()                   {}
func (*EventMessageValueOfObjectClose) IsEventMessageValue()                    {}
func (*EventMessageValueOfObjectRestrictionsSet) IsEventMessageValue()          {}
func (*EventMessageValueOfSubscriptionAdd) IsEventMessageValue()                {}
func (*EventMessageValueOfSubscriptionRemove) IsEventMessageValue()             {}
func (*EventMessageValueOfSubscriptionPosition) IsEventMessageValue()           {}
func (*EventMessageValueOfSubscriptionCounters) IsEventMessageValue()           {}
func (*EventMessageValueOfSubscriptionGroups) IsEventMessageValue()             {}
func (*EventMessageValueOfBlockAdd) IsEventMessageValue()                       {}
func (*EventMessageValueOfBlockDelete) IsEventMessageValue()                    {}
func (*EventMessageValueOfFilesUpload) IsEventMessageValue()                    {}
func (*EventMessageValueOfMarksInfo) IsEventMessageValue()                      {}
func (*EventMessageValueOfBlockSetFields) IsEventMessageValue()                 {}
func (*EventMessageValueOfBlockSetChildrenIds) IsEventMessageValue()            {}
func (*EventMessageValueOfBlockSetRestrictions) IsEventMessageValue()           {}
func (*EventMessageValueOfBlockSetBackgroundColor) IsEventMessageValue()        {}
func (*EventMessageValueOfBlockSetText) IsEventMessageValue()                   {}
func (*EventMessageValueOfBlockSetFile) IsEventMessageValue()                   {}
func (*EventMessageValueOfBlockSetLink) IsEventMessageValue()                   {}
func (*EventMessageValueOfBlockSetBookmark) IsEventMessageValue()               {}
func (*EventMessageValueOfBlockSetAlign) IsEventMessageValue()                  {}
func (*EventMessageValueOfBlockSetDiv) IsEventMessageValue()                    {}
func (*EventMessageValueOfBlockSetRelation) IsEventMessageValue()               {}
func (*EventMessageValueOfBlockSetLatex) IsEventMessageValue()                  {}
func (*EventMessageValueOfBlockSetVerticalAlign) IsEventMessageValue()          {}
func (*EventMessageValueOfBlockSetTableRow) IsEventMessageValue()               {}
func (*EventMessageValueOfBlockSetWidget) IsEventMessageValue()                 {}
func (*EventMessageValueOfBlockDataviewViewSet) IsEventMessageValue()           {}
func (*EventMessageValueOfBlockDataviewViewDelete) IsEventMessageValue()        {}
func (*EventMessageValueOfBlockDataviewViewOrder) IsEventMessageValue()         {}
func (*EventMessageValueOfBlockDataviewSourceSet) IsEventMessageValue()         {}
func (*EventMessageValueOfBlockDataViewGroupOrderUpdate) IsEventMessageValue()  {}
func (*EventMessageValueOfBlockDataViewObjectOrderUpdate) IsEventMessageValue() {}
func (*EventMessageValueOfBlockDataviewRelationDelete) IsEventMessageValue()    {}
func (*EventMessageValueOfBlockDataviewRelationSet) IsEventMessageValue()       {}
func (*EventMessageValueOfBlockDataviewViewUpdate) IsEventMessageValue()        {}
func (*EventMessageValueOfBlockDataviewTargetObjectIdSet) IsEventMessageValue() {}
func (*EventMessageValueOfBlockDataviewIsCollectionSet) IsEventMessageValue()   {}
func (*EventMessageValueOfBlockDataviewOldRelationDelete) IsEventMessageValue() {}
func (*EventMessageValueOfBlockDataviewOldRelationSet) IsEventMessageValue()    {}
func (*EventMessageValueOfUserBlockJoin) IsEventMessageValue()                  {}
func (*EventMessageValueOfUserBlockLeft) IsEventMessageValue()                  {}
func (*EventMessageValueOfUserBlockSelectRange) IsEventMessageValue()           {}
func (*EventMessageValueOfUserBlockTextRange) IsEventMessageValue()             {}
func (*EventMessageValueOfPing) IsEventMessageValue()                           {}
func (*EventMessageValueOfProcessNew) IsEventMessageValue()                     {}
func (*EventMessageValueOfProcessUpdate) IsEventMessageValue()                  {}
func (*EventMessageValueOfProcessDone) IsEventMessageValue()                    {}
func (*EventMessageValueOfThreadStatus) IsEventMessageValue()                   {}
func (*EventMessageValueOfFileLimitReached) IsEventMessageValue()               {}
func (*EventMessageValueOfFileSpaceUsage) IsEventMessageValue()                 {}
func (*EventMessageValueOfFileLocalUsage) IsEventMessageValue()                 {}
func (*EventMessageValueOfFileLimitUpdated) IsEventMessageValue()               {}
func (*EventMessageValueOfNotificationSend) IsEventMessageValue()               {}
func (*EventMessageValueOfNotificationUpdate) IsEventMessageValue()             {}
func (*EventMessageValueOfPayloadBroadcast) IsEventMessageValue()               {}
func (*EventMessageValueOfMembershipUpdate) IsEventMessageValue()               {}
func (*EventMessageValueOfSpaceSyncStatusUpdate) IsEventMessageValue()          {}
func (*EventMessageValueOfP2PStatusUpdate) IsEventMessageValue()                {}
func (*EventMessageValueOfImportFinish) IsEventMessageValue()                   {}
func (*EventMessageValueOfChatAdd) IsEventMessageValue()                        {}
func (*EventMessageValueOfChatUpdate) IsEventMessageValue()                     {}
func (*EventMessageValueOfChatUpdateReactions) IsEventMessageValue()            {}
func (*EventMessageValueOfChatUpdateMessageReadStatus) IsEventMessageValue()    {}
func (*EventMessageValueOfChatUpdateMentionReadStatus) IsEventMessageValue()    {}
func (*EventMessageValueOfChatUpdateMessageSyncStatus) IsEventMessageValue()    {}
func (*EventMessageValueOfChatDelete) IsEventMessageValue()                     {}
func (*EventMessageValueOfChatStateUpdate) IsEventMessageValue()                {}

func (m *EventMessage) GetValue() IsEventMessageValue {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *EventMessage) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

func (m *EventMessage) GetAccountShow() *EventAccountShow {
	if x, ok := m.GetValue().(*EventMessageValueOfAccountShow); ok {
		return x.AccountShow
	}
	return nil
}

func (m *EventMessage) GetAccountDetails() *EventAccountDetails {
	if x, ok := m.GetValue().(*EventMessageValueOfAccountDetails); ok {
		return x.AccountDetails
	}
	return nil
}

func (m *EventMessage) GetAccountConfigUpdate() *EventAccountConfigUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfAccountConfigUpdate); ok {
		return x.AccountConfigUpdate
	}
	return nil
}

func (m *EventMessage) GetAccountUpdate() *EventAccountUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfAccountUpdate); ok {
		return x.AccountUpdate
	}
	return nil
}

func (m *EventMessage) GetAccountLinkChallenge() *EventAccountLinkChallenge {
	if x, ok := m.GetValue().(*EventMessageValueOfAccountLinkChallenge); ok {
		return x.AccountLinkChallenge
	}
	return nil
}

func (m *EventMessage) GetAccountLinkChallengeHide() *EventAccountLinkChallengeHide {
	if x, ok := m.GetValue().(*EventMessageValueOfAccountLinkChallengeHide); ok {
		return x.AccountLinkChallengeHide
	}
	return nil
}

func (m *EventMessage) GetObjectDetailsSet() *EventObjectDetailsSet {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectDetailsSet); ok {
		return x.ObjectDetailsSet
	}
	return nil
}

func (m *EventMessage) GetObjectDetailsAmend() *EventObjectDetailsAmend {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectDetailsAmend); ok {
		return x.ObjectDetailsAmend
	}
	return nil
}

func (m *EventMessage) GetObjectDetailsUnset() *EventObjectDetailsUnset {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectDetailsUnset); ok {
		return x.ObjectDetailsUnset
	}
	return nil
}

func (m *EventMessage) GetObjectRelationsAmend() *EventObjectRelationsAmend {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectRelationsAmend); ok {
		return x.ObjectRelationsAmend
	}
	return nil
}

func (m *EventMessage) GetObjectRelationsRemove() *EventObjectRelationsRemove {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectRelationsRemove); ok {
		return x.ObjectRelationsRemove
	}
	return nil
}

func (m *EventMessage) GetObjectRemove() *EventObjectRemove {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectRemove); ok {
		return x.ObjectRemove
	}
	return nil
}

func (m *EventMessage) GetObjectClose() *EventObjectClose {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectClose); ok {
		return x.ObjectClose
	}
	return nil
}

func (m *EventMessage) GetObjectRestrictionsSet() *EventObjectRestrictionsSet {
	if x, ok := m.GetValue().(*EventMessageValueOfObjectRestrictionsSet); ok {
		return x.ObjectRestrictionsSet
	}
	return nil
}

func (m *EventMessage) GetSubscriptionAdd() *EventObjectSubscriptionAdd {
	if x, ok := m.GetValue().(*EventMessageValueOfSubscriptionAdd); ok {
		return x.SubscriptionAdd
	}
	return nil
}

func (m *EventMessage) GetSubscriptionRemove() *EventObjectSubscriptionRemove {
	if x, ok := m.GetValue().(*EventMessageValueOfSubscriptionRemove); ok {
		return x.SubscriptionRemove
	}
	return nil
}

func (m *EventMessage) GetSubscriptionPosition() *EventObjectSubscriptionPosition {
	if x, ok := m.GetValue().(*EventMessageValueOfSubscriptionPosition); ok {
		return x.SubscriptionPosition
	}
	return nil
}

func (m *EventMessage) GetSubscriptionCounters() *EventObjectSubscriptionCounters {
	if x, ok := m.GetValue().(*EventMessageValueOfSubscriptionCounters); ok {
		return x.SubscriptionCounters
	}
	return nil
}

func (m *EventMessage) GetSubscriptionGroups() *EventObjectSubscriptionGroups {
	if x, ok := m.GetValue().(*EventMessageValueOfSubscriptionGroups); ok {
		return x.SubscriptionGroups
	}
	return nil
}

func (m *EventMessage) GetBlockAdd() *EventBlockAdd {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockAdd); ok {
		return x.BlockAdd
	}
	return nil
}

func (m *EventMessage) GetBlockDelete() *EventBlockDelete {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDelete); ok {
		return x.BlockDelete
	}
	return nil
}

func (m *EventMessage) GetFilesUpload() *EventBlockFilesUpload {
	if x, ok := m.GetValue().(*EventMessageValueOfFilesUpload); ok {
		return x.FilesUpload
	}
	return nil
}

func (m *EventMessage) GetMarksInfo() *EventBlockMarksInfo {
	if x, ok := m.GetValue().(*EventMessageValueOfMarksInfo); ok {
		return x.MarksInfo
	}
	return nil
}

func (m *EventMessage) GetBlockSetFields() *EventBlockSetFields {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetFields); ok {
		return x.BlockSetFields
	}
	return nil
}

func (m *EventMessage) GetBlockSetChildrenIds() *EventBlockSetChildrenIds {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetChildrenIds); ok {
		return x.BlockSetChildrenIds
	}
	return nil
}

func (m *EventMessage) GetBlockSetRestrictions() *EventBlockSetRestrictions {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetRestrictions); ok {
		return x.BlockSetRestrictions
	}
	return nil
}

func (m *EventMessage) GetBlockSetBackgroundColor() *EventBlockSetBackgroundColor {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetBackgroundColor); ok {
		return x.BlockSetBackgroundColor
	}
	return nil
}

func (m *EventMessage) GetBlockSetText() *EventBlockSetText {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetText); ok {
		return x.BlockSetText
	}
	return nil
}

func (m *EventMessage) GetBlockSetFile() *EventBlockSetFile {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetFile); ok {
		return x.BlockSetFile
	}
	return nil
}

func (m *EventMessage) GetBlockSetLink() *EventBlockSetLink {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetLink); ok {
		return x.BlockSetLink
	}
	return nil
}

func (m *EventMessage) GetBlockSetBookmark() *EventBlockSetBookmark {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetBookmark); ok {
		return x.BlockSetBookmark
	}
	return nil
}

func (m *EventMessage) GetBlockSetAlign() *EventBlockSetAlign {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetAlign); ok {
		return x.BlockSetAlign
	}
	return nil
}

func (m *EventMessage) GetBlockSetDiv() *EventBlockSetDiv {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetDiv); ok {
		return x.BlockSetDiv
	}
	return nil
}

func (m *EventMessage) GetBlockSetRelation() *EventBlockSetRelation {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetRelation); ok {
		return x.BlockSetRelation
	}
	return nil
}

func (m *EventMessage) GetBlockSetLatex() *EventBlockSetLatex {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetLatex); ok {
		return x.BlockSetLatex
	}
	return nil
}

func (m *EventMessage) GetBlockSetVerticalAlign() *EventBlockSetVerticalAlign {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetVerticalAlign); ok {
		return x.BlockSetVerticalAlign
	}
	return nil
}

func (m *EventMessage) GetBlockSetTableRow() *EventBlockSetTableRow {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetTableRow); ok {
		return x.BlockSetTableRow
	}
	return nil
}

func (m *EventMessage) GetBlockSetWidget() *EventBlockSetWidget {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockSetWidget); ok {
		return x.BlockSetWidget
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewViewSet() *EventBlockDataviewViewSet {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewViewSet); ok {
		return x.BlockDataviewViewSet
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewViewDelete() *EventBlockDataviewViewDelete {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewViewDelete); ok {
		return x.BlockDataviewViewDelete
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewViewOrder() *EventBlockDataviewViewOrder {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewViewOrder); ok {
		return x.BlockDataviewViewOrder
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewSourceSet() *EventBlockDataviewSourceSet {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewSourceSet); ok {
		return x.BlockDataviewSourceSet
	}
	return nil
}

func (m *EventMessage) GetBlockDataViewGroupOrderUpdate() *EventBlockDataviewGroupOrderUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataViewGroupOrderUpdate); ok {
		return x.BlockDataViewGroupOrderUpdate
	}
	return nil
}

func (m *EventMessage) GetBlockDataViewObjectOrderUpdate() *EventBlockDataviewObjectOrderUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataViewObjectOrderUpdate); ok {
		return x.BlockDataViewObjectOrderUpdate
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewRelationDelete() *EventBlockDataviewRelationDelete {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewRelationDelete); ok {
		return x.BlockDataviewRelationDelete
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewRelationSet() *EventBlockDataviewRelationSet {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewRelationSet); ok {
		return x.BlockDataviewRelationSet
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewViewUpdate() *EventBlockDataviewViewUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewViewUpdate); ok {
		return x.BlockDataviewViewUpdate
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewTargetObjectIdSet() *EventBlockDataviewTargetObjectIdSet {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewTargetObjectIdSet); ok {
		return x.BlockDataviewTargetObjectIdSet
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewIsCollectionSet() *EventBlockDataviewIsCollectionSet {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewIsCollectionSet); ok {
		return x.BlockDataviewIsCollectionSet
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewOldRelationDelete() *EventBlockDataviewOldRelationDelete {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewOldRelationDelete); ok {
		return x.BlockDataviewOldRelationDelete
	}
	return nil
}

func (m *EventMessage) GetBlockDataviewOldRelationSet() *EventBlockDataviewOldRelationSet {
	if x, ok := m.GetValue().(*EventMessageValueOfBlockDataviewOldRelationSet); ok {
		return x.BlockDataviewOldRelationSet
	}
	return nil
}

func (m *EventMessage) GetUserBlockJoin() *EventUserBlockJoin {
	if x, ok := m.GetValue().(*EventMessageValueOfUserBlockJoin); ok {
		return x.UserBlockJoin
	}
	return nil
}

func (m *EventMessage) GetUserBlockLeft() *EventUserBlockLeft {
	if x, ok := m.GetValue().(*EventMessageValueOfUserBlockLeft); ok {
		return x.UserBlockLeft
	}
	return nil
}

func (m *EventMessage) GetUserBlockSelectRange() *EventUserBlockSelectRange {
	if x, ok := m.GetValue().(*EventMessageValueOfUserBlockSelectRange); ok {
		return x.UserBlockSelectRange
	}
	return nil
}

func (m *EventMessage) GetUserBlockTextRange() *EventUserBlockTextRange {
	if x, ok := m.GetValue().(*EventMessageValueOfUserBlockTextRange); ok {
		return x.UserBlockTextRange
	}
	return nil
}

func (m *EventMessage) GetPing() *EventPing {
	if x, ok := m.GetValue().(*EventMessageValueOfPing); ok {
		return x.Ping
	}
	return nil
}

func (m *EventMessage) GetProcessNew() *EventProcessNew {
	if x, ok := m.GetValue().(*EventMessageValueOfProcessNew); ok {
		return x.ProcessNew
	}
	return nil
}

func (m *EventMessage) GetProcessUpdate() *EventProcessUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfProcessUpdate); ok {
		return x.ProcessUpdate
	}
	return nil
}

func (m *EventMessage) GetProcessDone() *EventProcessDone {
	if x, ok := m.GetValue().(*EventMessageValueOfProcessDone); ok {
		return x.ProcessDone
	}
	return nil
}

func (m *EventMessage) GetThreadStatus() *EventStatusThread {
	if x, ok := m.GetValue().(*EventMessageValueOfThreadStatus); ok {
		return x.ThreadStatus
	}
	return nil
}

func (m *EventMessage) GetFileLimitReached() *EventFileLimitReached {
	if x, ok := m.GetValue().(*EventMessageValueOfFileLimitReached); ok {
		return x.FileLimitReached
	}
	return nil
}

func (m *EventMessage) GetFileSpaceUsage() *EventFileSpaceUsage {
	if x, ok := m.GetValue().(*EventMessageValueOfFileSpaceUsage); ok {
		return x.FileSpaceUsage
	}
	return nil
}

func (m *EventMessage) GetFileLocalUsage() *EventFileLocalUsage {
	if x, ok := m.GetValue().(*EventMessageValueOfFileLocalUsage); ok {
		return x.FileLocalUsage
	}
	return nil
}

func (m *EventMessage) GetFileLimitUpdated() *EventFileLimitUpdated {
	if x, ok := m.GetValue().(*EventMessageValueOfFileLimitUpdated); ok {
		return x.FileLimitUpdated
	}
	return nil
}

func (m *EventMessage) GetNotificationSend() *EventNotificationSend {
	if x, ok := m.GetValue().(*EventMessageValueOfNotificationSend); ok {
		return x.NotificationSend
	}
	return nil
}

func (m *EventMessage) GetNotificationUpdate() *EventNotificationUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfNotificationUpdate); ok {
		return x.NotificationUpdate
	}
	return nil
}

func (m *EventMessage) GetPayloadBroadcast() *EventPayloadBroadcast {
	if x, ok := m.GetValue().(*EventMessageValueOfPayloadBroadcast); ok {
		return x.PayloadBroadcast
	}
	return nil
}

func (m *EventMessage) GetMembershipUpdate() *EventMembershipUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfMembershipUpdate); ok {
		return x.MembershipUpdate
	}
	return nil
}

func (m *EventMessage) GetSpaceSyncStatusUpdate() *EventSpaceSyncStatusUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfSpaceSyncStatusUpdate); ok {
		return x.SpaceSyncStatusUpdate
	}
	return nil
}

func (m *EventMessage) GetP2PStatusUpdate() *EventP2PStatusUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfP2PStatusUpdate); ok {
		return x.P2PStatusUpdate
	}
	return nil
}

func (m *EventMessage) GetImportFinish() *EventImportFinish {
	if x, ok := m.GetValue().(*EventMessageValueOfImportFinish); ok {
		return x.ImportFinish
	}
	return nil
}

func (m *EventMessage) GetChatAdd() *EventChatAdd {
	if x, ok := m.GetValue().(*EventMessageValueOfChatAdd); ok {
		return x.ChatAdd
	}
	return nil
}

func (m *EventMessage) GetChatUpdate() *EventChatUpdate {
	if x, ok := m.GetValue().(*EventMessageValueOfChatUpdate); ok {
		return x.ChatUpdate
	}
	return nil
}

func (m *EventMessage) GetChatUpdateReactions() *EventChatUpdateReactions {
	if x, ok := m.GetValue().(*EventMessageValueOfChatUpdateReactions); ok {
		return x.ChatUpdateReactions
	}
	return nil
}

func (m *EventMessage) GetChatUpdateMessageReadStatus() *EventChatUpdateMessageReadStatus {
	if x, ok := m.GetValue().(*EventMessageValueOfChatUpdateMessageReadStatus); ok {
		return x.ChatUpdateMessageReadStatus
	}
	return nil
}

func (m *EventMessage) GetChatUpdateMentionReadStatus() *EventChatUpdateMentionReadStatus {
	if x, ok := m.GetValue().(*EventMessageValueOfChatUpdateMentionReadStatus); ok {
		return x.ChatUpdateMentionReadStatus
	}
	return nil
}

func (m *EventMessage) GetChatUpdateMessageSyncStatus() *EventChatUpdateMessageSyncStatus {
	if x, ok := m.GetValue().(*EventMessageValueOfChatUpdateMessageSyncStatus); ok {
		return x.ChatUpdateMessageSyncStatus
	}
	return nil
}

func (m *EventMessage) GetChatDelete() *EventChatDelete {
	if x, ok := m.GetValue().(*EventMessageValueOfChatDelete); ok {
		return x.ChatDelete
	}
	return nil
}

func (m *EventMessage) GetChatStateUpdate() *EventChatUpdateState {
	if x, ok := m.GetValue().(*EventMessageValueOfChatStateUpdate); ok {
		return x.ChatStateUpdate
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EventMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EventMessageValueOfAccountShow)(nil),
		(*EventMessageValueOfAccountDetails)(nil),
		(*EventMessageValueOfAccountConfigUpdate)(nil),
		(*EventMessageValueOfAccountUpdate)(nil),
		(*EventMessageValueOfAccountLinkChallenge)(nil),
		(*EventMessageValueOfAccountLinkChallengeHide)(nil),
		(*EventMessageValueOfObjectDetailsSet)(nil),
		(*EventMessageValueOfObjectDetailsAmend)(nil),
		(*EventMessageValueOfObjectDetailsUnset)(nil),
		(*EventMessageValueOfObjectRelationsAmend)(nil),
		(*EventMessageValueOfObjectRelationsRemove)(nil),
		(*EventMessageValueOfObjectRemove)(nil),
		(*EventMessageValueOfObjectClose)(nil),
		(*EventMessageValueOfObjectRestrictionsSet)(nil),
		(*EventMessageValueOfSubscriptionAdd)(nil),
		(*EventMessageValueOfSubscriptionRemove)(nil),
		(*EventMessageValueOfSubscriptionPosition)(nil),
		(*EventMessageValueOfSubscriptionCounters)(nil),
		(*EventMessageValueOfSubscriptionGroups)(nil),
		(*EventMessageValueOfBlockAdd)(nil),
		(*EventMessageValueOfBlockDelete)(nil),
		(*EventMessageValueOfFilesUpload)(nil),
		(*EventMessageValueOfMarksInfo)(nil),
		(*EventMessageValueOfBlockSetFields)(nil),
		(*EventMessageValueOfBlockSetChildrenIds)(nil),
		(*EventMessageValueOfBlockSetRestrictions)(nil),
		(*EventMessageValueOfBlockSetBackgroundColor)(nil),
		(*EventMessageValueOfBlockSetText)(nil),
		(*EventMessageValueOfBlockSetFile)(nil),
		(*EventMessageValueOfBlockSetLink)(nil),
		(*EventMessageValueOfBlockSetBookmark)(nil),
		(*EventMessageValueOfBlockSetAlign)(nil),
		(*EventMessageValueOfBlockSetDiv)(nil),
		(*EventMessageValueOfBlockSetRelation)(nil),
		(*EventMessageValueOfBlockSetLatex)(nil),
		(*EventMessageValueOfBlockSetVerticalAlign)(nil),
		(*EventMessageValueOfBlockSetTableRow)(nil),
		(*EventMessageValueOfBlockSetWidget)(nil),
		(*EventMessageValueOfBlockDataviewViewSet)(nil),
		(*EventMessageValueOfBlockDataviewViewDelete)(nil),
		(*EventMessageValueOfBlockDataviewViewOrder)(nil),
		(*EventMessageValueOfBlockDataviewSourceSet)(nil),
		(*EventMessageValueOfBlockDataViewGroupOrderUpdate)(nil),
		(*EventMessageValueOfBlockDataViewObjectOrderUpdate)(nil),
		(*EventMessageValueOfBlockDataviewRelationDelete)(nil),
		(*EventMessageValueOfBlockDataviewRelationSet)(nil),
		(*EventMessageValueOfBlockDataviewViewUpdate)(nil),
		(*EventMessageValueOfBlockDataviewTargetObjectIdSet)(nil),
		(*EventMessageValueOfBlockDataviewIsCollectionSet)(nil),
		(*EventMessageValueOfBlockDataviewOldRelationDelete)(nil),
		(*EventMessageValueOfBlockDataviewOldRelationSet)(nil),
		(*EventMessageValueOfUserBlockJoin)(nil),
		(*EventMessageValueOfUserBlockLeft)(nil),
		(*EventMessageValueOfUserBlockSelectRange)(nil),
		(*EventMessageValueOfUserBlockTextRange)(nil),
		(*EventMessageValueOfPing)(nil),
		(*EventMessageValueOfProcessNew)(nil),
		(*EventMessageValueOfProcessUpdate)(nil),
		(*EventMessageValueOfProcessDone)(nil),
		(*EventMessageValueOfThreadStatus)(nil),
		(*EventMessageValueOfFileLimitReached)(nil),
		(*EventMessageValueOfFileSpaceUsage)(nil),
		(*EventMessageValueOfFileLocalUsage)(nil),
		(*EventMessageValueOfFileLimitUpdated)(nil),
		(*EventMessageValueOfNotificationSend)(nil),
		(*EventMessageValueOfNotificationUpdate)(nil),
		(*EventMessageValueOfPayloadBroadcast)(nil),
		(*EventMessageValueOfMembershipUpdate)(nil),
		(*EventMessageValueOfSpaceSyncStatusUpdate)(nil),
		(*EventMessageValueOfP2PStatusUpdate)(nil),
		(*EventMessageValueOfImportFinish)(nil),
		(*EventMessageValueOfChatAdd)(nil),
		(*EventMessageValueOfChatUpdate)(nil),
		(*EventMessageValueOfChatUpdateReactions)(nil),
		(*EventMessageValueOfChatUpdateMessageReadStatus)(nil),
		(*EventMessageValueOfChatUpdateMentionReadStatus)(nil),
		(*EventMessageValueOfChatUpdateMessageSyncStatus)(nil),
		(*EventMessageValueOfChatDelete)(nil),
		(*EventMessageValueOfChatStateUpdate)(nil),
	}
}

type EventChat struct {
}

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

var xxx_messageInfo_EventChat proto.InternalMessageInfo

type EventChatAdd struct {
	Id           string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	OrderId      string             `protobuf:"bytes,2,opt,name=orderId,proto3" json:"orderId,omitempty"`
	AfterOrderId string             `protobuf:"bytes,6,opt,name=afterOrderId,proto3" json:"afterOrderId,omitempty"`
	Message      *model.ChatMessage `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	SubIds       []string           `protobuf:"bytes,4,rep,name=subIds,proto3" json:"subIds,omitempty"`
	Dependencies []*types.Struct    `protobuf:"bytes,5,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
}

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

var xxx_messageInfo_EventChatAdd proto.InternalMessageInfo

func (m *EventChatAdd) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventChatAdd) GetOrderId() string {
	if m != nil {
		return m.OrderId
	}
	return ""
}

func (m *EventChatAdd) GetAfterOrderId() string {
	if m != nil {
		return m.AfterOrderId
	}
	return ""
}

func (m *EventChatAdd) GetMessage() *model.ChatMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *EventChatAdd) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

func (m *EventChatAdd) GetDependencies() []*types.Struct {
	if m != nil {
		return m.Dependencies
	}
	return nil
}

type EventChatDelete struct {
	Id     string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SubIds []string `protobuf:"bytes,2,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatDelete proto.InternalMessageInfo

func (m *EventChatDelete) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventChatDelete) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventChatUpdate struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Message *model.ChatMessage `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	SubIds  []string           `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatUpdate proto.InternalMessageInfo

func (m *EventChatUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventChatUpdate) GetMessage() *model.ChatMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *EventChatUpdate) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventChatUpdateReactions struct {
	Id        string                      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Reactions *model.ChatMessageReactions `protobuf:"bytes,2,opt,name=reactions,proto3" json:"reactions,omitempty"`
	SubIds    []string                    `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatUpdateReactions proto.InternalMessageInfo

func (m *EventChatUpdateReactions) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventChatUpdateReactions) GetReactions() *model.ChatMessageReactions {
	if m != nil {
		return m.Reactions
	}
	return nil
}

func (m *EventChatUpdateReactions) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventChatUpdateMessageReadStatus struct {
	Ids    []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	IsRead bool     `protobuf:"varint,2,opt,name=isRead,proto3" json:"isRead,omitempty"`
	SubIds []string `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatUpdateMessageReadStatus proto.InternalMessageInfo

func (m *EventChatUpdateMessageReadStatus) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *EventChatUpdateMessageReadStatus) GetIsRead() bool {
	if m != nil {
		return m.IsRead
	}
	return false
}

func (m *EventChatUpdateMessageReadStatus) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventChatUpdateMentionReadStatus struct {
	Ids    []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	IsRead bool     `protobuf:"varint,2,opt,name=isRead,proto3" json:"isRead,omitempty"`
	SubIds []string `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatUpdateMentionReadStatus proto.InternalMessageInfo

func (m *EventChatUpdateMentionReadStatus) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *EventChatUpdateMentionReadStatus) GetIsRead() bool {
	if m != nil {
		return m.IsRead
	}
	return false
}

func (m *EventChatUpdateMentionReadStatus) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventChatUpdateMessageSyncStatus struct {
	Ids      []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	IsSynced bool     `protobuf:"varint,2,opt,name=isSynced,proto3" json:"isSynced,omitempty"`
	SubIds   []string `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatUpdateMessageSyncStatus proto.InternalMessageInfo

func (m *EventChatUpdateMessageSyncStatus) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *EventChatUpdateMessageSyncStatus) GetIsSynced() bool {
	if m != nil {
		return m.IsSynced
	}
	return false
}

func (m *EventChatUpdateMessageSyncStatus) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventChatUpdateState struct {
	State  *model.ChatState `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	SubIds []string         `protobuf:"bytes,2,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventChatUpdateState proto.InternalMessageInfo

func (m *EventChatUpdateState) GetState() *model.ChatState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *EventChatUpdateState) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventAccount struct {
}

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

var xxx_messageInfo_EventAccount proto.InternalMessageInfo

// *
// Message, that will be sent to the front on each account found after an
// AccountRecoverRequest
type EventAccountShow struct {
	Index   int32          `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Account *model.Account `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_EventAccountShow proto.InternalMessageInfo

func (m *EventAccountShow) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *EventAccountShow) GetAccount() *model.Account {
	if m != nil {
		return m.Account
	}
	return nil
}

type EventAccountDetails struct {
	ProfileId string        `protobuf:"bytes,1,opt,name=profileId,proto3" json:"profileId,omitempty"`
	Details   *types.Struct `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_EventAccountDetails proto.InternalMessageInfo

func (m *EventAccountDetails) GetProfileId() string {
	if m != nil {
		return m.ProfileId
	}
	return ""
}

func (m *EventAccountDetails) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

type EventAccountConfig struct {
}

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

var xxx_messageInfo_EventAccountConfig proto.InternalMessageInfo

type EventAccountConfigUpdate struct {
	Config *model.AccountConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	Status *model.AccountStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_EventAccountConfigUpdate proto.InternalMessageInfo

func (m *EventAccountConfigUpdate) GetConfig() *model.AccountConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *EventAccountConfigUpdate) GetStatus() *model.AccountStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type EventAccountUpdate struct {
	Config *model.AccountConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	Status *model.AccountStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_EventAccountUpdate proto.InternalMessageInfo

func (m *EventAccountUpdate) GetConfig() *model.AccountConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *EventAccountUpdate) GetStatus() *model.AccountStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type EventAccountLinkChallenge struct {
	Challenge  string                               `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
	ClientInfo *EventAccountLinkChallengeClientInfo `protobuf:"bytes,2,opt,name=clientInfo,proto3" json:"clientInfo,omitempty"`
	Scope      model.AccountAuthLocalApiScope       `protobuf:"varint,3,opt,name=scope,proto3,enum=anytype.model.AccountAuthLocalApiScope" json:"scope,omitempty"`
}

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

var xxx_messageInfo_EventAccountLinkChallenge proto.InternalMessageInfo

func (m *EventAccountLinkChallenge) GetChallenge() string {
	if m != nil {
		return m.Challenge
	}
	return ""
}

func (m *EventAccountLinkChallenge) GetClientInfo() *EventAccountLinkChallengeClientInfo {
	if m != nil {
		return m.ClientInfo
	}
	return nil
}

func (m *EventAccountLinkChallenge) GetScope() model.AccountAuthLocalApiScope {
	if m != nil {
		return m.Scope
	}
	return model.AccountAuth_Limited
}

type EventAccountLinkChallengeClientInfo struct {
	ProcessName       string `protobuf:"bytes,1,opt,name=processName,proto3" json:"processName,omitempty"`
	ProcessPath       string `protobuf:"bytes,2,opt,name=processPath,proto3" json:"processPath,omitempty"`
	Name              string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	SignatureVerified bool   `protobuf:"varint,3,opt,name=signatureVerified,proto3" json:"signatureVerified,omitempty"`
}

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

var xxx_messageInfo_EventAccountLinkChallengeClientInfo proto.InternalMessageInfo

func (m *EventAccountLinkChallengeClientInfo) GetProcessName() string {
	if m != nil {
		return m.ProcessName
	}
	return ""
}

func (m *EventAccountLinkChallengeClientInfo) GetProcessPath() string {
	if m != nil {
		return m.ProcessPath
	}
	return ""
}

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

func (m *EventAccountLinkChallengeClientInfo) GetSignatureVerified() bool {
	if m != nil {
		return m.SignatureVerified
	}
	return false
}

type EventAccountLinkChallengeHide struct {
	Challenge string `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
}

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

var xxx_messageInfo_EventAccountLinkChallengeHide proto.InternalMessageInfo

func (m *EventAccountLinkChallengeHide) GetChallenge() string {
	if m != nil {
		return m.Challenge
	}
	return ""
}

type EventObject struct {
}

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

var xxx_messageInfo_EventObject proto.InternalMessageInfo

type EventObjectDetails struct {
}

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

var xxx_messageInfo_EventObjectDetails proto.InternalMessageInfo

// Amend (i.e. add a new key-value pair or update an existing key-value
// pair) existing state
type EventObjectDetailsAmend struct {
	Id      string                             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Details []*EventObjectDetailsAmendKeyValue `protobuf:"bytes,2,rep,name=details,proto3" json:"details,omitempty"`
	SubIds  []string                           `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventObjectDetailsAmend proto.InternalMessageInfo

func (m *EventObjectDetailsAmend) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectDetailsAmend) GetDetails() []*EventObjectDetailsAmendKeyValue {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *EventObjectDetailsAmend) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventObjectDetailsAmendKeyValue struct {
	Key   string       `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value *types.Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventObjectDetailsAmendKeyValue proto.InternalMessageInfo

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

func (m *EventObjectDetailsAmendKeyValue) GetValue() *types.Value {
	if m != nil {
		return m.Value
	}
	return nil
}

// Overwrite current state
type EventObjectDetailsSet struct {
	Id      string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Details *types.Struct `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	// state
	SubIds []string `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventObjectDetailsSet proto.InternalMessageInfo

func (m *EventObjectDetailsSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectDetailsSet) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *EventObjectDetailsSet) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

// Unset existing detail keys
type EventObjectDetailsUnset struct {
	Id     string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Keys   []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"`
	SubIds []string `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_EventObjectDetailsUnset proto.InternalMessageInfo

func (m *EventObjectDetailsUnset) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectDetailsUnset) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *EventObjectDetailsUnset) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type EventObjectSubscription struct {
}

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

var xxx_messageInfo_EventObjectSubscription proto.InternalMessageInfo

// Adds new document to subscriptions
type EventObjectSubscriptionAdd struct {
	Id      string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	AfterId string `protobuf:"bytes,2,opt,name=afterId,proto3" json:"afterId,omitempty"`
	SubId   string `protobuf:"bytes,3,opt,name=subId,proto3" json:"subId,omitempty"`
}

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

var xxx_messageInfo_EventObjectSubscriptionAdd proto.InternalMessageInfo

func (m *EventObjectSubscriptionAdd) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectSubscriptionAdd) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventObjectSubscriptionAdd) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

// Removes document from subscription
type EventObjectSubscriptionRemove struct {
	Id    string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SubId string `protobuf:"bytes,2,opt,name=subId,proto3" json:"subId,omitempty"`
}

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

var xxx_messageInfo_EventObjectSubscriptionRemove proto.InternalMessageInfo

func (m *EventObjectSubscriptionRemove) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectSubscriptionRemove) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

// Indicates new position of document
type EventObjectSubscriptionPosition struct {
	Id      string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	AfterId string `protobuf:"bytes,2,opt,name=afterId,proto3" json:"afterId,omitempty"`
	SubId   string `protobuf:"bytes,3,opt,name=subId,proto3" json:"subId,omitempty"`
}

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

var xxx_messageInfo_EventObjectSubscriptionPosition proto.InternalMessageInfo

func (m *EventObjectSubscriptionPosition) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectSubscriptionPosition) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventObjectSubscriptionPosition) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

type EventObjectSubscriptionCounters struct {
	// total available records
	Total int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	// how many records available after
	NextCount int64 `protobuf:"varint,2,opt,name=nextCount,proto3" json:"nextCount,omitempty"`
	// how many records available before
	PrevCount int64  `protobuf:"varint,3,opt,name=prevCount,proto3" json:"prevCount,omitempty"`
	SubId     string `protobuf:"bytes,4,opt,name=subId,proto3" json:"subId,omitempty"`
}

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

var xxx_messageInfo_EventObjectSubscriptionCounters proto.InternalMessageInfo

func (m *EventObjectSubscriptionCounters) GetTotal() int64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *EventObjectSubscriptionCounters) GetNextCount() int64 {
	if m != nil {
		return m.NextCount
	}
	return 0
}

func (m *EventObjectSubscriptionCounters) GetPrevCount() int64 {
	if m != nil {
		return m.PrevCount
	}
	return 0
}

func (m *EventObjectSubscriptionCounters) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

type EventObjectSubscriptionGroups struct {
	SubId  string                           `protobuf:"bytes,1,opt,name=subId,proto3" json:"subId,omitempty"`
	Group  *model.BlockContentDataviewGroup `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
	Remove bool                             `protobuf:"varint,3,opt,name=remove,proto3" json:"remove,omitempty"`
}

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

var xxx_messageInfo_EventObjectSubscriptionGroups proto.InternalMessageInfo

func (m *EventObjectSubscriptionGroups) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

func (m *EventObjectSubscriptionGroups) GetGroup() *model.BlockContentDataviewGroup {
	if m != nil {
		return m.Group
	}
	return nil
}

func (m *EventObjectSubscriptionGroups) GetRemove() bool {
	if m != nil {
		return m.Remove
	}
	return false
}

type EventObjectRelations struct {
}

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

var xxx_messageInfo_EventObjectRelations proto.InternalMessageInfo

type EventObjectRelationsAmend struct {
	Id            string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RelationLinks []*model.RelationLink `protobuf:"bytes,2,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
}

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

var xxx_messageInfo_EventObjectRelationsAmend proto.InternalMessageInfo

func (m *EventObjectRelationsAmend) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectRelationsAmend) GetRelationLinks() []*model.RelationLink {
	if m != nil {
		return m.RelationLinks
	}
	return nil
}

type EventObjectRelationsRemove struct {
	Id           string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RelationKeys []string `protobuf:"bytes,2,rep,name=relationKeys,proto3" json:"relationKeys,omitempty"`
}

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

var xxx_messageInfo_EventObjectRelationsRemove proto.InternalMessageInfo

func (m *EventObjectRelationsRemove) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectRelationsRemove) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	return nil
}

type EventObjectRemove struct {
	// notifies that objects were removed
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventObjectRemove proto.InternalMessageInfo

func (m *EventObjectRemove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventObjectRestrictions struct {
}

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

var xxx_messageInfo_EventObjectRestrictions proto.InternalMessageInfo

type EventObjectRestrictionsSet struct {
	Id           string              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Restrictions *model.Restrictions `protobuf:"bytes,2,opt,name=restrictions,proto3" json:"restrictions,omitempty"`
}

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

var xxx_messageInfo_EventObjectRestrictionsSet proto.InternalMessageInfo

func (m *EventObjectRestrictionsSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventObjectRestrictionsSet) GetRestrictions() *model.Restrictions {
	if m != nil {
		return m.Restrictions
	}
	return nil
}

type EventObjectClose struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_EventObjectClose proto.InternalMessageInfo

func (m *EventObjectClose) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type EventBlock struct {
}

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

var xxx_messageInfo_EventBlock proto.InternalMessageInfo

// Event to show internal blocks on a client.
// Example Scenarios
// A. Block Creation
// 1. Block A have been created on a client C1
// 2. Client C2 receives Event.Block.Add(Block A),
// Event.Block.Update(Page.children) B. Partial block load
// 1. Client C1 opens Page1, that contains, for example, 133 blocks.
// 2. M -> F: ShowFullScreen(Root, blocks1-50)
// 3. M -> F: Block.Add(blocks51-100)
// 3. M -> F: Block.Add(blocks101-133)
type EventBlockAdd struct {
	Blocks []*model.Block `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
}

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

var xxx_messageInfo_EventBlockAdd proto.InternalMessageInfo

func (m *EventBlockAdd) GetBlocks() []*model.Block {
	if m != nil {
		return m.Blocks
	}
	return nil
}

// *
// Middleware to front end event message, that will be sent on one of this
// scenarios: Precondition: user A opened a block
// 1. User A drops a set of files/pictures/videos
// 2. User A creates a MediaBlock and drops a single media, that corresponds
// to its type.
type EventBlockFilesUpload struct {
	BlockId  string   `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
	FilePath []string `protobuf:"bytes,2,rep,name=filePath,proto3" json:"filePath,omitempty"`
}

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

var xxx_messageInfo_EventBlockFilesUpload proto.InternalMessageInfo

func (m *EventBlockFilesUpload) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *EventBlockFilesUpload) GetFilePath() []string {
	if m != nil {
		return m.FilePath
	}
	return nil
}

type EventBlockDelete struct {
	BlockIds []string `protobuf:"bytes,1,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
}

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

var xxx_messageInfo_EventBlockDelete proto.InternalMessageInfo

func (m *EventBlockDelete) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type EventBlockMarksInfo struct {
	MarksInRange []model.BlockContentTextMarkType `protobuf:"varint,1,rep,packed,name=marksInRange,proto3,enum=anytype.model.BlockContentTextMarkType" json:"marksInRange,omitempty"`
}

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

var xxx_messageInfo_EventBlockMarksInfo proto.InternalMessageInfo

func (m *EventBlockMarksInfo) GetMarksInRange() []model.BlockContentTextMarkType {
	if m != nil {
		return m.MarksInRange
	}
	return nil
}

type EventBlockSet struct {
}

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

var xxx_messageInfo_EventBlockSet proto.InternalMessageInfo

type EventBlockSetRelation struct {
	Id  string                    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Key *EventBlockSetRelationKey `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetRelation proto.InternalMessageInfo

func (m *EventBlockSetRelation) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetRelation) GetKey() *EventBlockSetRelationKey {
	if m != nil {
		return m.Key
	}
	return nil
}

type EventBlockSetRelationKey struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetRelationKey proto.InternalMessageInfo

func (m *EventBlockSetRelationKey) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetFields struct {
	Id     string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Fields *types.Struct `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFields proto.InternalMessageInfo

func (m *EventBlockSetFields) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetFields) GetFields() *types.Struct {
	if m != nil {
		return m.Fields
	}
	return nil
}

type EventBlockSetChildrenIds struct {
	Id          string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ChildrenIds []string `protobuf:"bytes,2,rep,name=childrenIds,proto3" json:"childrenIds,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetChildrenIds proto.InternalMessageInfo

func (m *EventBlockSetChildrenIds) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetChildrenIds) GetChildrenIds() []string {
	if m != nil {
		return m.ChildrenIds
	}
	return nil
}

type EventBlockSetRestrictions struct {
	Id           string                   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Restrictions *model.BlockRestrictions `protobuf:"bytes,2,opt,name=restrictions,proto3" json:"restrictions,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetRestrictions proto.InternalMessageInfo

func (m *EventBlockSetRestrictions) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetRestrictions) GetRestrictions() *model.BlockRestrictions {
	if m != nil {
		return m.Restrictions
	}
	return nil
}

type EventBlockSetBackgroundColor struct {
	Id              string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	BackgroundColor string `protobuf:"bytes,2,opt,name=backgroundColor,proto3" json:"backgroundColor,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBackgroundColor proto.InternalMessageInfo

func (m *EventBlockSetBackgroundColor) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetBackgroundColor) GetBackgroundColor() string {
	if m != nil {
		return m.BackgroundColor
	}
	return ""
}

type EventBlockSetAlign struct {
	Id    string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Align model.BlockAlign `protobuf:"varint,2,opt,name=align,proto3,enum=anytype.model.BlockAlign" json:"align,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetAlign proto.InternalMessageInfo

func (m *EventBlockSetAlign) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetAlign) GetAlign() model.BlockAlign {
	if m != nil {
		return m.Align
	}
	return model.Block_AlignLeft
}

type EventBlockSetVerticalAlign struct {
	Id            string                   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	VerticalAlign model.BlockVerticalAlign `protobuf:"varint,2,opt,name=verticalAlign,proto3,enum=anytype.model.BlockVerticalAlign" json:"verticalAlign,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetVerticalAlign proto.InternalMessageInfo

func (m *EventBlockSetVerticalAlign) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetVerticalAlign) GetVerticalAlign() model.BlockVerticalAlign {
	if m != nil {
		return m.VerticalAlign
	}
	return model.Block_VerticalAlignTop
}

type EventBlockSetText struct {
	Id        string                      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Text      *EventBlockSetTextText      `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	Style     *EventBlockSetTextStyle     `protobuf:"bytes,3,opt,name=style,proto3" json:"style,omitempty"`
	Marks     *EventBlockSetTextMarks     `protobuf:"bytes,4,opt,name=marks,proto3" json:"marks,omitempty"`
	Checked   *EventBlockSetTextChecked   `protobuf:"bytes,5,opt,name=checked,proto3" json:"checked,omitempty"`
	Color     *EventBlockSetTextColor     `protobuf:"bytes,6,opt,name=color,proto3" json:"color,omitempty"`
	IconEmoji *EventBlockSetTextIconEmoji `protobuf:"bytes,7,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"`
	IconImage *EventBlockSetTextIconImage `protobuf:"bytes,8,opt,name=iconImage,proto3" json:"iconImage,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetText proto.InternalMessageInfo

func (m *EventBlockSetText) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetText) GetText() *EventBlockSetTextText {
	if m != nil {
		return m.Text
	}
	return nil
}

func (m *EventBlockSetText) GetStyle() *EventBlockSetTextStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

func (m *EventBlockSetText) GetMarks() *EventBlockSetTextMarks {
	if m != nil {
		return m.Marks
	}
	return nil
}

func (m *EventBlockSetText) GetChecked() *EventBlockSetTextChecked {
	if m != nil {
		return m.Checked
	}
	return nil
}

func (m *EventBlockSetText) GetColor() *EventBlockSetTextColor {
	if m != nil {
		return m.Color
	}
	return nil
}

func (m *EventBlockSetText) GetIconEmoji() *EventBlockSetTextIconEmoji {
	if m != nil {
		return m.IconEmoji
	}
	return nil
}

func (m *EventBlockSetText) GetIconImage() *EventBlockSetTextIconImage {
	if m != nil {
		return m.IconImage
	}
	return nil
}

type EventBlockSetTextText struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextText proto.InternalMessageInfo

func (m *EventBlockSetTextText) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetTextStyle struct {
	Value model.BlockContentTextStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentTextStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextStyle proto.InternalMessageInfo

func (m *EventBlockSetTextStyle) GetValue() model.BlockContentTextStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentText_Paragraph
}

type EventBlockSetTextMarks struct {
	Value *model.BlockContentTextMarks `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextMarks proto.InternalMessageInfo

func (m *EventBlockSetTextMarks) GetValue() *model.BlockContentTextMarks {
	if m != nil {
		return m.Value
	}
	return nil
}

type EventBlockSetTextChecked struct {
	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextChecked proto.InternalMessageInfo

func (m *EventBlockSetTextChecked) GetValue() bool {
	if m != nil {
		return m.Value
	}
	return false
}

type EventBlockSetTextColor struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextColor proto.InternalMessageInfo

func (m *EventBlockSetTextColor) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetTextIconEmoji struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextIconEmoji proto.InternalMessageInfo

func (m *EventBlockSetTextIconEmoji) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetTextIconImage struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTextIconImage proto.InternalMessageInfo

func (m *EventBlockSetTextIconImage) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetLatex struct {
	Id        string                       `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Text      *EventBlockSetLatexText      `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	Processor *EventBlockSetLatexProcessor `protobuf:"bytes,3,opt,name=processor,proto3" json:"processor,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLatex proto.InternalMessageInfo

func (m *EventBlockSetLatex) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetLatex) GetText() *EventBlockSetLatexText {
	if m != nil {
		return m.Text
	}
	return nil
}

func (m *EventBlockSetLatex) GetProcessor() *EventBlockSetLatexProcessor {
	if m != nil {
		return m.Processor
	}
	return nil
}

type EventBlockSetLatexText struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLatexText proto.InternalMessageInfo

func (m *EventBlockSetLatexText) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetLatexProcessor struct {
	Value model.BlockContentLatexProcessor `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentLatexProcessor" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLatexProcessor proto.InternalMessageInfo

func (m *EventBlockSetLatexProcessor) GetValue() model.BlockContentLatexProcessor {
	if m != nil {
		return m.Value
	}
	return model.BlockContentLatex_Latex
}

type EventBlockSetDiv struct {
	Id    string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Style *EventBlockSetDivStyle `protobuf:"bytes,2,opt,name=style,proto3" json:"style,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetDiv proto.InternalMessageInfo

func (m *EventBlockSetDiv) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetDiv) GetStyle() *EventBlockSetDivStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

type EventBlockSetDivStyle struct {
	Value model.BlockContentDivStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentDivStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetDivStyle proto.InternalMessageInfo

func (m *EventBlockSetDivStyle) GetValue() model.BlockContentDivStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentDiv_Line
}

type EventBlockSetFile struct {
	Id             string                           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type           *EventBlockSetFileType           `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	State          *EventBlockSetFileState          `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
	Mime           *EventBlockSetFileMime           `protobuf:"bytes,4,opt,name=mime,proto3" json:"mime,omitempty"`
	Hash           *EventBlockSetFileHash           `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"`
	Name           *EventBlockSetFileName           `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"`
	Size_          *EventBlockSetFileSize           `protobuf:"bytes,7,opt,name=size,proto3" json:"size,omitempty"`
	Style          *EventBlockSetFileStyle          `protobuf:"bytes,8,opt,name=style,proto3" json:"style,omitempty"`
	TargetObjectId *EventBlockSetFileTargetObjectId `protobuf:"bytes,9,opt,name=targetObjectId,proto3" json:"targetObjectId,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFile proto.InternalMessageInfo

func (m *EventBlockSetFile) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetFile) GetType() *EventBlockSetFileType {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *EventBlockSetFile) GetState() *EventBlockSetFileState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *EventBlockSetFile) GetMime() *EventBlockSetFileMime {
	if m != nil {
		return m.Mime
	}
	return nil
}

func (m *EventBlockSetFile) GetHash() *EventBlockSetFileHash {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *EventBlockSetFile) GetName() *EventBlockSetFileName {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *EventBlockSetFile) GetSize_() *EventBlockSetFileSize {
	if m != nil {
		return m.Size_
	}
	return nil
}

func (m *EventBlockSetFile) GetStyle() *EventBlockSetFileStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

func (m *EventBlockSetFile) GetTargetObjectId() *EventBlockSetFileTargetObjectId {
	if m != nil {
		return m.TargetObjectId
	}
	return nil
}

type EventBlockSetFileName struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileName proto.InternalMessageInfo

func (m *EventBlockSetFileName) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetFileWidth struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileWidth proto.InternalMessageInfo

func (m *EventBlockSetFileWidth) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type EventBlockSetFileState struct {
	Value model.BlockContentFileState `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentFileState" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileState proto.InternalMessageInfo

func (m *EventBlockSetFileState) GetValue() model.BlockContentFileState {
	if m != nil {
		return m.Value
	}
	return model.BlockContentFile_Empty
}

type EventBlockSetFileType struct {
	Value model.BlockContentFileType `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentFileType" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileType proto.InternalMessageInfo

func (m *EventBlockSetFileType) GetValue() model.BlockContentFileType {
	if m != nil {
		return m.Value
	}
	return model.BlockContentFile_None
}

type EventBlockSetFileStyle struct {
	Value model.BlockContentFileStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentFileStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileStyle proto.InternalMessageInfo

func (m *EventBlockSetFileStyle) GetValue() model.BlockContentFileStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentFile_Auto
}

type EventBlockSetFileHash struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileHash proto.InternalMessageInfo

func (m *EventBlockSetFileHash) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetFileMime struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileMime proto.InternalMessageInfo

func (m *EventBlockSetFileMime) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetFileSize struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileSize proto.InternalMessageInfo

func (m *EventBlockSetFileSize) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type EventBlockSetFileTargetObjectId struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetFileTargetObjectId proto.InternalMessageInfo

func (m *EventBlockSetFileTargetObjectId) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetLink struct {
	Id            string                          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	TargetBlockId *EventBlockSetLinkTargetBlockId `protobuf:"bytes,2,opt,name=targetBlockId,proto3" json:"targetBlockId,omitempty"`
	Style         *EventBlockSetLinkStyle         `protobuf:"bytes,3,opt,name=style,proto3" json:"style,omitempty"`
	Fields        *EventBlockSetLinkFields        `protobuf:"bytes,4,opt,name=fields,proto3" json:"fields,omitempty"`
	IconSize      *EventBlockSetLinkIconSize      `protobuf:"bytes,5,opt,name=iconSize,proto3" json:"iconSize,omitempty"`
	CardStyle     *EventBlockSetLinkCardStyle     `protobuf:"bytes,6,opt,name=cardStyle,proto3" json:"cardStyle,omitempty"`
	Description   *EventBlockSetLinkDescription   `protobuf:"bytes,7,opt,name=description,proto3" json:"description,omitempty"`
	Relations     *EventBlockSetLinkRelations     `protobuf:"bytes,8,opt,name=relations,proto3" json:"relations,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLink proto.InternalMessageInfo

func (m *EventBlockSetLink) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetLink) GetTargetBlockId() *EventBlockSetLinkTargetBlockId {
	if m != nil {
		return m.TargetBlockId
	}
	return nil
}

func (m *EventBlockSetLink) GetStyle() *EventBlockSetLinkStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

func (m *EventBlockSetLink) GetFields() *EventBlockSetLinkFields {
	if m != nil {
		return m.Fields
	}
	return nil
}

func (m *EventBlockSetLink) GetIconSize() *EventBlockSetLinkIconSize {
	if m != nil {
		return m.IconSize
	}
	return nil
}

func (m *EventBlockSetLink) GetCardStyle() *EventBlockSetLinkCardStyle {
	if m != nil {
		return m.CardStyle
	}
	return nil
}

func (m *EventBlockSetLink) GetDescription() *EventBlockSetLinkDescription {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *EventBlockSetLink) GetRelations() *EventBlockSetLinkRelations {
	if m != nil {
		return m.Relations
	}
	return nil
}

type EventBlockSetLinkTargetBlockId struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkTargetBlockId proto.InternalMessageInfo

func (m *EventBlockSetLinkTargetBlockId) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetLinkStyle struct {
	Value model.BlockContentLinkStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentLinkStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkStyle proto.InternalMessageInfo

func (m *EventBlockSetLinkStyle) GetValue() model.BlockContentLinkStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentLink_Page
}

type EventBlockSetLinkFields struct {
	Value *types.Struct `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkFields proto.InternalMessageInfo

func (m *EventBlockSetLinkFields) GetValue() *types.Struct {
	if m != nil {
		return m.Value
	}
	return nil
}

type EventBlockSetLinkIconSize struct {
	Value model.BlockContentLinkIconSize `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentLinkIconSize" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkIconSize proto.InternalMessageInfo

func (m *EventBlockSetLinkIconSize) GetValue() model.BlockContentLinkIconSize {
	if m != nil {
		return m.Value
	}
	return model.BlockContentLink_SizeNone
}

type EventBlockSetLinkCardStyle struct {
	Value model.BlockContentLinkCardStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentLinkCardStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkCardStyle proto.InternalMessageInfo

func (m *EventBlockSetLinkCardStyle) GetValue() model.BlockContentLinkCardStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentLink_Text
}

type EventBlockSetLinkDescription struct {
	Value model.BlockContentLinkDescription `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentLinkDescription" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkDescription proto.InternalMessageInfo

func (m *EventBlockSetLinkDescription) GetValue() model.BlockContentLinkDescription {
	if m != nil {
		return m.Value
	}
	return model.BlockContentLink_None
}

type EventBlockSetLinkRelations struct {
	Value []string `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetLinkRelations proto.InternalMessageInfo

func (m *EventBlockSetLinkRelations) GetValue() []string {
	if m != nil {
		return m.Value
	}
	return nil
}

type EventBlockSetBookmark struct {
	Id             string                               `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Url            *EventBlockSetBookmarkUrl            `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	Title          *EventBlockSetBookmarkTitle          `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	Description    *EventBlockSetBookmarkDescription    `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	ImageHash      *EventBlockSetBookmarkImageHash      `protobuf:"bytes,5,opt,name=imageHash,proto3" json:"imageHash,omitempty"`
	FaviconHash    *EventBlockSetBookmarkFaviconHash    `protobuf:"bytes,6,opt,name=faviconHash,proto3" json:"faviconHash,omitempty"`
	Type           *EventBlockSetBookmarkType           `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
	TargetObjectId *EventBlockSetBookmarkTargetObjectId `protobuf:"bytes,8,opt,name=targetObjectId,proto3" json:"targetObjectId,omitempty"`
	State          *EventBlockSetBookmarkState          `protobuf:"bytes,9,opt,name=state,proto3" json:"state,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmark proto.InternalMessageInfo

func (m *EventBlockSetBookmark) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetBookmark) GetUrl() *EventBlockSetBookmarkUrl {
	if m != nil {
		return m.Url
	}
	return nil
}

func (m *EventBlockSetBookmark) GetTitle() *EventBlockSetBookmarkTitle {
	if m != nil {
		return m.Title
	}
	return nil
}

func (m *EventBlockSetBookmark) GetDescription() *EventBlockSetBookmarkDescription {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *EventBlockSetBookmark) GetImageHash() *EventBlockSetBookmarkImageHash {
	if m != nil {
		return m.ImageHash
	}
	return nil
}

func (m *EventBlockSetBookmark) GetFaviconHash() *EventBlockSetBookmarkFaviconHash {
	if m != nil {
		return m.FaviconHash
	}
	return nil
}

func (m *EventBlockSetBookmark) GetType() *EventBlockSetBookmarkType {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *EventBlockSetBookmark) GetTargetObjectId() *EventBlockSetBookmarkTargetObjectId {
	if m != nil {
		return m.TargetObjectId
	}
	return nil
}

func (m *EventBlockSetBookmark) GetState() *EventBlockSetBookmarkState {
	if m != nil {
		return m.State
	}
	return nil
}

type EventBlockSetBookmarkUrl struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkUrl proto.InternalMessageInfo

func (m *EventBlockSetBookmarkUrl) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetBookmarkTitle struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkTitle proto.InternalMessageInfo

func (m *EventBlockSetBookmarkTitle) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetBookmarkDescription struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkDescription proto.InternalMessageInfo

func (m *EventBlockSetBookmarkDescription) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetBookmarkImageHash struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkImageHash proto.InternalMessageInfo

func (m *EventBlockSetBookmarkImageHash) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetBookmarkFaviconHash struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkFaviconHash proto.InternalMessageInfo

func (m *EventBlockSetBookmarkFaviconHash) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetBookmarkType struct {
	Value model.LinkPreviewType `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.LinkPreviewType" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkType proto.InternalMessageInfo

func (m *EventBlockSetBookmarkType) GetValue() model.LinkPreviewType {
	if m != nil {
		return m.Value
	}
	return model.LinkPreview_Unknown
}

type EventBlockSetBookmarkTargetObjectId struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkTargetObjectId proto.InternalMessageInfo

func (m *EventBlockSetBookmarkTargetObjectId) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockSetBookmarkState struct {
	Value model.BlockContentBookmarkState `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentBookmarkState" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetBookmarkState proto.InternalMessageInfo

func (m *EventBlockSetBookmarkState) GetValue() model.BlockContentBookmarkState {
	if m != nil {
		return m.Value
	}
	return model.BlockContentBookmark_Empty
}

type EventBlockSetTableRow struct {
	Id       string                         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	IsHeader *EventBlockSetTableRowIsHeader `protobuf:"bytes,2,opt,name=isHeader,proto3" json:"isHeader,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTableRow proto.InternalMessageInfo

func (m *EventBlockSetTableRow) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetTableRow) GetIsHeader() *EventBlockSetTableRowIsHeader {
	if m != nil {
		return m.IsHeader
	}
	return nil
}

type EventBlockSetTableRowIsHeader struct {
	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetTableRowIsHeader proto.InternalMessageInfo

func (m *EventBlockSetTableRowIsHeader) GetValue() bool {
	if m != nil {
		return m.Value
	}
	return false
}

type EventBlockSetWidget struct {
	Id     string                     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Layout *EventBlockSetWidgetLayout `protobuf:"bytes,2,opt,name=layout,proto3" json:"layout,omitempty"`
	Limit  *EventBlockSetWidgetLimit  `protobuf:"bytes,3,opt,name=limit,proto3" json:"limit,omitempty"`
	ViewId *EventBlockSetWidgetViewId `protobuf:"bytes,4,opt,name=viewId,proto3" json:"viewId,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetWidget proto.InternalMessageInfo

func (m *EventBlockSetWidget) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockSetWidget) GetLayout() *EventBlockSetWidgetLayout {
	if m != nil {
		return m.Layout
	}
	return nil
}

func (m *EventBlockSetWidget) GetLimit() *EventBlockSetWidgetLimit {
	if m != nil {
		return m.Limit
	}
	return nil
}

func (m *EventBlockSetWidget) GetViewId() *EventBlockSetWidgetViewId {
	if m != nil {
		return m.ViewId
	}
	return nil
}

type EventBlockSetWidgetLayout struct {
	Value model.BlockContentWidgetLayout `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentWidgetLayout" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetWidgetLayout proto.InternalMessageInfo

func (m *EventBlockSetWidgetLayout) GetValue() model.BlockContentWidgetLayout {
	if m != nil {
		return m.Value
	}
	return model.BlockContentWidget_Link
}

type EventBlockSetWidgetLimit struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetWidgetLimit proto.InternalMessageInfo

func (m *EventBlockSetWidgetLimit) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type EventBlockSetWidgetViewId struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockSetWidgetViewId proto.InternalMessageInfo

func (m *EventBlockSetWidgetViewId) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFill struct {
}

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

var xxx_messageInfo_EventBlockFill proto.InternalMessageInfo

type EventBlockFillDetails struct {
	Id      string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Details *types.Struct `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillDetails proto.InternalMessageInfo

func (m *EventBlockFillDetails) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillDetails) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

type EventBlockFillDatabaseRecords struct {
	Id      string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Records []*types.Struct `protobuf:"bytes,2,rep,name=records,proto3" json:"records,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillDatabaseRecords proto.InternalMessageInfo

func (m *EventBlockFillDatabaseRecords) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillDatabaseRecords) GetRecords() []*types.Struct {
	if m != nil {
		return m.Records
	}
	return nil
}

type EventBlockFillFields struct {
	Id     string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Fields *types.Struct `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFields proto.InternalMessageInfo

func (m *EventBlockFillFields) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillFields) GetFields() *types.Struct {
	if m != nil {
		return m.Fields
	}
	return nil
}

type EventBlockFillChildrenIds struct {
	Id          string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ChildrenIds []string `protobuf:"bytes,2,rep,name=childrenIds,proto3" json:"childrenIds,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillChildrenIds proto.InternalMessageInfo

func (m *EventBlockFillChildrenIds) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillChildrenIds) GetChildrenIds() []string {
	if m != nil {
		return m.ChildrenIds
	}
	return nil
}

type EventBlockFillRestrictions struct {
	Id           string                   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Restrictions *model.BlockRestrictions `protobuf:"bytes,2,opt,name=restrictions,proto3" json:"restrictions,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillRestrictions proto.InternalMessageInfo

func (m *EventBlockFillRestrictions) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillRestrictions) GetRestrictions() *model.BlockRestrictions {
	if m != nil {
		return m.Restrictions
	}
	return nil
}

type EventBlockFillBackgroundColor struct {
	Id              string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	BackgroundColor string `protobuf:"bytes,2,opt,name=backgroundColor,proto3" json:"backgroundColor,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBackgroundColor proto.InternalMessageInfo

func (m *EventBlockFillBackgroundColor) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillBackgroundColor) GetBackgroundColor() string {
	if m != nil {
		return m.BackgroundColor
	}
	return ""
}

type EventBlockFillAlign struct {
	Id    string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Align model.BlockAlign `protobuf:"varint,2,opt,name=align,proto3,enum=anytype.model.BlockAlign" json:"align,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillAlign proto.InternalMessageInfo

func (m *EventBlockFillAlign) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillAlign) GetAlign() model.BlockAlign {
	if m != nil {
		return m.Align
	}
	return model.Block_AlignLeft
}

type EventBlockFillText struct {
	Id      string                     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Text    *EventBlockFillTextText    `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	Style   *EventBlockFillTextStyle   `protobuf:"bytes,3,opt,name=style,proto3" json:"style,omitempty"`
	Marks   *EventBlockFillTextMarks   `protobuf:"bytes,4,opt,name=marks,proto3" json:"marks,omitempty"`
	Checked *EventBlockFillTextChecked `protobuf:"bytes,5,opt,name=checked,proto3" json:"checked,omitempty"`
	Color   *EventBlockFillTextColor   `protobuf:"bytes,6,opt,name=color,proto3" json:"color,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillText proto.InternalMessageInfo

func (m *EventBlockFillText) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillText) GetText() *EventBlockFillTextText {
	if m != nil {
		return m.Text
	}
	return nil
}

func (m *EventBlockFillText) GetStyle() *EventBlockFillTextStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

func (m *EventBlockFillText) GetMarks() *EventBlockFillTextMarks {
	if m != nil {
		return m.Marks
	}
	return nil
}

func (m *EventBlockFillText) GetChecked() *EventBlockFillTextChecked {
	if m != nil {
		return m.Checked
	}
	return nil
}

func (m *EventBlockFillText) GetColor() *EventBlockFillTextColor {
	if m != nil {
		return m.Color
	}
	return nil
}

type EventBlockFillTextText struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillTextText proto.InternalMessageInfo

func (m *EventBlockFillTextText) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillTextStyle struct {
	Value model.BlockContentTextStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentTextStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillTextStyle proto.InternalMessageInfo

func (m *EventBlockFillTextStyle) GetValue() model.BlockContentTextStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentText_Paragraph
}

type EventBlockFillTextMarks struct {
	Value *model.BlockContentTextMarks `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillTextMarks proto.InternalMessageInfo

func (m *EventBlockFillTextMarks) GetValue() *model.BlockContentTextMarks {
	if m != nil {
		return m.Value
	}
	return nil
}

type EventBlockFillTextChecked struct {
	Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillTextChecked proto.InternalMessageInfo

func (m *EventBlockFillTextChecked) GetValue() bool {
	if m != nil {
		return m.Value
	}
	return false
}

type EventBlockFillTextColor struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillTextColor proto.InternalMessageInfo

func (m *EventBlockFillTextColor) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillDiv struct {
	Id    string                  `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Style *EventBlockFillDivStyle `protobuf:"bytes,2,opt,name=style,proto3" json:"style,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillDiv proto.InternalMessageInfo

func (m *EventBlockFillDiv) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillDiv) GetStyle() *EventBlockFillDivStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

type EventBlockFillDivStyle struct {
	Value model.BlockContentDivStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentDivStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillDivStyle proto.InternalMessageInfo

func (m *EventBlockFillDivStyle) GetValue() model.BlockContentDivStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentDiv_Line
}

type EventBlockFillFile struct {
	Id    string                   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type  *EventBlockFillFileType  `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	State *EventBlockFillFileState `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
	Mime  *EventBlockFillFileMime  `protobuf:"bytes,4,opt,name=mime,proto3" json:"mime,omitempty"`
	Hash  *EventBlockFillFileHash  `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"`
	Name  *EventBlockFillFileName  `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"`
	Size_ *EventBlockFillFileSize  `protobuf:"bytes,7,opt,name=size,proto3" json:"size,omitempty"`
	Style *EventBlockFillFileStyle `protobuf:"bytes,8,opt,name=style,proto3" json:"style,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFile proto.InternalMessageInfo

func (m *EventBlockFillFile) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillFile) GetType() *EventBlockFillFileType {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *EventBlockFillFile) GetState() *EventBlockFillFileState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *EventBlockFillFile) GetMime() *EventBlockFillFileMime {
	if m != nil {
		return m.Mime
	}
	return nil
}

func (m *EventBlockFillFile) GetHash() *EventBlockFillFileHash {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *EventBlockFillFile) GetName() *EventBlockFillFileName {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *EventBlockFillFile) GetSize_() *EventBlockFillFileSize {
	if m != nil {
		return m.Size_
	}
	return nil
}

func (m *EventBlockFillFile) GetStyle() *EventBlockFillFileStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

type EventBlockFillFileName struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileName proto.InternalMessageInfo

func (m *EventBlockFillFileName) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillFileWidth struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileWidth proto.InternalMessageInfo

func (m *EventBlockFillFileWidth) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type EventBlockFillFileState struct {
	Value model.BlockContentFileState `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentFileState" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileState proto.InternalMessageInfo

func (m *EventBlockFillFileState) GetValue() model.BlockContentFileState {
	if m != nil {
		return m.Value
	}
	return model.BlockContentFile_Empty
}

type EventBlockFillFileType struct {
	Value model.BlockContentFileType `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentFileType" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileType proto.InternalMessageInfo

func (m *EventBlockFillFileType) GetValue() model.BlockContentFileType {
	if m != nil {
		return m.Value
	}
	return model.BlockContentFile_None
}

type EventBlockFillFileStyle struct {
	Value model.BlockContentFileStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentFileStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileStyle proto.InternalMessageInfo

func (m *EventBlockFillFileStyle) GetValue() model.BlockContentFileStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentFile_Auto
}

type EventBlockFillFileHash struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileHash proto.InternalMessageInfo

func (m *EventBlockFillFileHash) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillFileMime struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileMime proto.InternalMessageInfo

func (m *EventBlockFillFileMime) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillFileSize struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillFileSize proto.InternalMessageInfo

func (m *EventBlockFillFileSize) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type EventBlockFillLink struct {
	Id            string                           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	TargetBlockId *EventBlockFillLinkTargetBlockId `protobuf:"bytes,2,opt,name=targetBlockId,proto3" json:"targetBlockId,omitempty"`
	Style         *EventBlockFillLinkStyle         `protobuf:"bytes,3,opt,name=style,proto3" json:"style,omitempty"`
	Fields        *EventBlockFillLinkFields        `protobuf:"bytes,4,opt,name=fields,proto3" json:"fields,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillLink proto.InternalMessageInfo

func (m *EventBlockFillLink) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillLink) GetTargetBlockId() *EventBlockFillLinkTargetBlockId {
	if m != nil {
		return m.TargetBlockId
	}
	return nil
}

func (m *EventBlockFillLink) GetStyle() *EventBlockFillLinkStyle {
	if m != nil {
		return m.Style
	}
	return nil
}

func (m *EventBlockFillLink) GetFields() *EventBlockFillLinkFields {
	if m != nil {
		return m.Fields
	}
	return nil
}

type EventBlockFillLinkTargetBlockId struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillLinkTargetBlockId proto.InternalMessageInfo

func (m *EventBlockFillLinkTargetBlockId) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillLinkStyle struct {
	Value model.BlockContentLinkStyle `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.BlockContentLinkStyle" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillLinkStyle proto.InternalMessageInfo

func (m *EventBlockFillLinkStyle) GetValue() model.BlockContentLinkStyle {
	if m != nil {
		return m.Value
	}
	return model.BlockContentLink_Page
}

type EventBlockFillLinkFields struct {
	Value *types.Struct `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillLinkFields proto.InternalMessageInfo

func (m *EventBlockFillLinkFields) GetValue() *types.Struct {
	if m != nil {
		return m.Value
	}
	return nil
}

type EventBlockFillBookmark struct {
	Id             string                                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Url            *EventBlockFillBookmarkUrl            `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	Title          *EventBlockFillBookmarkTitle          `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	Description    *EventBlockFillBookmarkDescription    `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	ImageHash      *EventBlockFillBookmarkImageHash      `protobuf:"bytes,5,opt,name=imageHash,proto3" json:"imageHash,omitempty"`
	FaviconHash    *EventBlockFillBookmarkFaviconHash    `protobuf:"bytes,6,opt,name=faviconHash,proto3" json:"faviconHash,omitempty"`
	Type           *EventBlockFillBookmarkType           `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
	TargetObjectId *EventBlockFillBookmarkTargetObjectId `protobuf:"bytes,8,opt,name=targetObjectId,proto3" json:"targetObjectId,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmark proto.InternalMessageInfo

func (m *EventBlockFillBookmark) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockFillBookmark) GetUrl() *EventBlockFillBookmarkUrl {
	if m != nil {
		return m.Url
	}
	return nil
}

func (m *EventBlockFillBookmark) GetTitle() *EventBlockFillBookmarkTitle {
	if m != nil {
		return m.Title
	}
	return nil
}

func (m *EventBlockFillBookmark) GetDescription() *EventBlockFillBookmarkDescription {
	if m != nil {
		return m.Description
	}
	return nil
}

func (m *EventBlockFillBookmark) GetImageHash() *EventBlockFillBookmarkImageHash {
	if m != nil {
		return m.ImageHash
	}
	return nil
}

func (m *EventBlockFillBookmark) GetFaviconHash() *EventBlockFillBookmarkFaviconHash {
	if m != nil {
		return m.FaviconHash
	}
	return nil
}

func (m *EventBlockFillBookmark) GetType() *EventBlockFillBookmarkType {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *EventBlockFillBookmark) GetTargetObjectId() *EventBlockFillBookmarkTargetObjectId {
	if m != nil {
		return m.TargetObjectId
	}
	return nil
}

type EventBlockFillBookmarkUrl struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkUrl proto.InternalMessageInfo

func (m *EventBlockFillBookmarkUrl) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillBookmarkTitle struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkTitle proto.InternalMessageInfo

func (m *EventBlockFillBookmarkTitle) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillBookmarkDescription struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkDescription proto.InternalMessageInfo

func (m *EventBlockFillBookmarkDescription) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillBookmarkImageHash struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkImageHash proto.InternalMessageInfo

func (m *EventBlockFillBookmarkImageHash) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillBookmarkFaviconHash struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkFaviconHash proto.InternalMessageInfo

func (m *EventBlockFillBookmarkFaviconHash) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockFillBookmarkType struct {
	Value model.LinkPreviewType `protobuf:"varint,1,opt,name=value,proto3,enum=anytype.model.LinkPreviewType" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkType proto.InternalMessageInfo

func (m *EventBlockFillBookmarkType) GetValue() model.LinkPreviewType {
	if m != nil {
		return m.Value
	}
	return model.LinkPreview_Unknown
}

type EventBlockFillBookmarkTargetObjectId struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockFillBookmarkTargetObjectId proto.InternalMessageInfo

func (m *EventBlockFillBookmarkTargetObjectId) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type EventBlockDataview struct {
}

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

var xxx_messageInfo_EventBlockDataview proto.InternalMessageInfo

// sent when the view have been changed or added
type EventBlockDataviewViewSet struct {
	Id     string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ViewId string `protobuf:"bytes,2,opt,name=viewId,proto3" json:"viewId,omitempty"`
	// doesn't switch the active view in the middle
	View *model.BlockContentDataviewView `protobuf:"bytes,3,opt,name=view,proto3" json:"view,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewSet proto.InternalMessageInfo

func (m *EventBlockDataviewViewSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewSet) GetViewId() string {
	if m != nil {
		return m.ViewId
	}
	return ""
}

func (m *EventBlockDataviewViewSet) GetView() *model.BlockContentDataviewView {
	if m != nil {
		return m.View
	}
	return nil
}

type EventBlockDataviewViewUpdate struct {
	Id       string                                  `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ViewId   string                                  `protobuf:"bytes,2,opt,name=viewId,proto3" json:"viewId,omitempty"`
	Filter   []*EventBlockDataviewViewUpdateFilter   `protobuf:"bytes,3,rep,name=filter,proto3" json:"filter,omitempty"`
	Relation []*EventBlockDataviewViewUpdateRelation `protobuf:"bytes,4,rep,name=relation,proto3" json:"relation,omitempty"`
	Sort     []*EventBlockDataviewViewUpdateSort     `protobuf:"bytes,5,rep,name=sort,proto3" json:"sort,omitempty"`
	Fields   *EventBlockDataviewViewUpdateFields     `protobuf:"bytes,6,opt,name=fields,proto3" json:"fields,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdate proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewUpdate) GetViewId() string {
	if m != nil {
		return m.ViewId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdate) GetFilter() []*EventBlockDataviewViewUpdateFilter {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (m *EventBlockDataviewViewUpdate) GetRelation() []*EventBlockDataviewViewUpdateRelation {
	if m != nil {
		return m.Relation
	}
	return nil
}

func (m *EventBlockDataviewViewUpdate) GetSort() []*EventBlockDataviewViewUpdateSort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *EventBlockDataviewViewUpdate) GetFields() *EventBlockDataviewViewUpdateFields {
	if m != nil {
		return m.Fields
	}
	return nil
}

type EventBlockDataviewViewUpdateFields struct {
	Type                  model.BlockContentDataviewViewType `protobuf:"varint,1,opt,name=type,proto3,enum=anytype.model.BlockContentDataviewViewType" json:"type,omitempty"`
	Name                  string                             `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	CoverRelationKey      string                             `protobuf:"bytes,3,opt,name=coverRelationKey,proto3" json:"coverRelationKey,omitempty"`
	HideIcon              bool                               `protobuf:"varint,4,opt,name=hideIcon,proto3" json:"hideIcon,omitempty"`
	CardSize              model.BlockContentDataviewViewSize `protobuf:"varint,5,opt,name=cardSize,proto3,enum=anytype.model.BlockContentDataviewViewSize" json:"cardSize,omitempty"`
	CoverFit              bool                               `protobuf:"varint,6,opt,name=coverFit,proto3" json:"coverFit,omitempty"`
	GroupRelationKey      string                             `protobuf:"bytes,7,opt,name=groupRelationKey,proto3" json:"groupRelationKey,omitempty"`
	EndRelationKey        string                             `protobuf:"bytes,16,opt,name=endRelationKey,proto3" json:"endRelationKey,omitempty"`
	GroupBackgroundColors bool                               `protobuf:"varint,8,opt,name=groupBackgroundColors,proto3" json:"groupBackgroundColors,omitempty"`
	PageLimit             int32                              `protobuf:"varint,9,opt,name=pageLimit,proto3" json:"pageLimit,omitempty"`
	DefaultTemplateId     string                             `protobuf:"bytes,10,opt,name=defaultTemplateId,proto3" json:"defaultTemplateId,omitempty"`
	DefaultObjectTypeId   string                             `protobuf:"bytes,15,opt,name=defaultObjectTypeId,proto3" json:"defaultObjectTypeId,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateFields proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateFields) GetType() model.BlockContentDataviewViewType {
	if m != nil {
		return m.Type
	}
	return model.BlockContentDataviewView_Table
}

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

func (m *EventBlockDataviewViewUpdateFields) GetCoverRelationKey() string {
	if m != nil {
		return m.CoverRelationKey
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFields) GetHideIcon() bool {
	if m != nil {
		return m.HideIcon
	}
	return false
}

func (m *EventBlockDataviewViewUpdateFields) GetCardSize() model.BlockContentDataviewViewSize {
	if m != nil {
		return m.CardSize
	}
	return model.BlockContentDataviewView_Small
}

func (m *EventBlockDataviewViewUpdateFields) GetCoverFit() bool {
	if m != nil {
		return m.CoverFit
	}
	return false
}

func (m *EventBlockDataviewViewUpdateFields) GetGroupRelationKey() string {
	if m != nil {
		return m.GroupRelationKey
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFields) GetEndRelationKey() string {
	if m != nil {
		return m.EndRelationKey
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFields) GetGroupBackgroundColors() bool {
	if m != nil {
		return m.GroupBackgroundColors
	}
	return false
}

func (m *EventBlockDataviewViewUpdateFields) GetPageLimit() int32 {
	if m != nil {
		return m.PageLimit
	}
	return 0
}

func (m *EventBlockDataviewViewUpdateFields) GetDefaultTemplateId() string {
	if m != nil {
		return m.DefaultTemplateId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFields) GetDefaultObjectTypeId() string {
	if m != nil {
		return m.DefaultObjectTypeId
	}
	return ""
}

type EventBlockDataviewViewUpdateFilter struct {
	// Types that are valid to be assigned to Operation:
	//
	//	*EventBlockDataviewViewUpdateFilterOperationOfAdd
	//	*EventBlockDataviewViewUpdateFilterOperationOfRemove
	//	*EventBlockDataviewViewUpdateFilterOperationOfUpdate
	//	*EventBlockDataviewViewUpdateFilterOperationOfMove
	Operation IsEventBlockDataviewViewUpdateFilterOperation `protobuf_oneof:"operation"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateFilter proto.InternalMessageInfo

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

type EventBlockDataviewViewUpdateFilterOperationOfAdd struct {
	Add *EventBlockDataviewViewUpdateFilterAdd `protobuf:"bytes,1,opt,name=add,proto3,oneof" json:"add,omitempty"`
}
type EventBlockDataviewViewUpdateFilterOperationOfRemove struct {
	Remove *EventBlockDataviewViewUpdateFilterRemove `protobuf:"bytes,2,opt,name=remove,proto3,oneof" json:"remove,omitempty"`
}
type EventBlockDataviewViewUpdateFilterOperationOfUpdate struct {
	Update *EventBlockDataviewViewUpdateFilterUpdate `protobuf:"bytes,3,opt,name=update,proto3,oneof" json:"update,omitempty"`
}
type EventBlockDataviewViewUpdateFilterOperationOfMove struct {
	Move *EventBlockDataviewViewUpdateFilterMove `protobuf:"bytes,4,opt,name=move,proto3,oneof" json:"move,omitempty"`
}

func (*EventBlockDataviewViewUpdateFilterOperationOfAdd) IsEventBlockDataviewViewUpdateFilterOperation() {
}
func (*EventBlockDataviewViewUpdateFilterOperationOfRemove) IsEventBlockDataviewViewUpdateFilterOperation() {
}
func (*EventBlockDataviewViewUpdateFilterOperationOfUpdate) IsEventBlockDataviewViewUpdateFilterOperation() {
}
func (*EventBlockDataviewViewUpdateFilterOperationOfMove) IsEventBlockDataviewViewUpdateFilterOperation() {
}

func (m *EventBlockDataviewViewUpdateFilter) GetOperation() IsEventBlockDataviewViewUpdateFilterOperation {
	if m != nil {
		return m.Operation
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateFilter) GetAdd() *EventBlockDataviewViewUpdateFilterAdd {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateFilterOperationOfAdd); ok {
		return x.Add
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateFilter) GetRemove() *EventBlockDataviewViewUpdateFilterRemove {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateFilterOperationOfRemove); ok {
		return x.Remove
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateFilter) GetUpdate() *EventBlockDataviewViewUpdateFilterUpdate {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateFilterOperationOfUpdate); ok {
		return x.Update
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateFilter) GetMove() *EventBlockDataviewViewUpdateFilterMove {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateFilterOperationOfMove); ok {
		return x.Move
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EventBlockDataviewViewUpdateFilter) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EventBlockDataviewViewUpdateFilterOperationOfAdd)(nil),
		(*EventBlockDataviewViewUpdateFilterOperationOfRemove)(nil),
		(*EventBlockDataviewViewUpdateFilterOperationOfUpdate)(nil),
		(*EventBlockDataviewViewUpdateFilterOperationOfMove)(nil),
	}
}

type EventBlockDataviewViewUpdateFilterAdd struct {
	AfterId string                              `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Items   []*model.BlockContentDataviewFilter `protobuf:"bytes,2,rep,name=items,proto3" json:"items,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateFilterAdd proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateFilterAdd) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFilterAdd) GetItems() []*model.BlockContentDataviewFilter {
	if m != nil {
		return m.Items
	}
	return nil
}

type EventBlockDataviewViewUpdateFilterRemove struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateFilterRemove proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateFilterRemove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventBlockDataviewViewUpdateFilterUpdate struct {
	Id   string                            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Item *model.BlockContentDataviewFilter `protobuf:"bytes,2,opt,name=item,proto3" json:"item,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateFilterUpdate proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateFilterUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFilterUpdate) GetItem() *model.BlockContentDataviewFilter {
	if m != nil {
		return m.Item
	}
	return nil
}

type EventBlockDataviewViewUpdateFilterMove struct {
	AfterId string   `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Ids     []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateFilterMove proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateFilterMove) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateFilterMove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventBlockDataviewViewUpdateRelation struct {
	// Types that are valid to be assigned to Operation:
	//
	//	*EventBlockDataviewViewUpdateRelationOperationOfAdd
	//	*EventBlockDataviewViewUpdateRelationOperationOfRemove
	//	*EventBlockDataviewViewUpdateRelationOperationOfUpdate
	//	*EventBlockDataviewViewUpdateRelationOperationOfMove
	Operation IsEventBlockDataviewViewUpdateRelationOperation `protobuf_oneof:"operation"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateRelation proto.InternalMessageInfo

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

type EventBlockDataviewViewUpdateRelationOperationOfAdd struct {
	Add *EventBlockDataviewViewUpdateRelationAdd `protobuf:"bytes,1,opt,name=add,proto3,oneof" json:"add,omitempty"`
}
type EventBlockDataviewViewUpdateRelationOperationOfRemove struct {
	Remove *EventBlockDataviewViewUpdateRelationRemove `protobuf:"bytes,2,opt,name=remove,proto3,oneof" json:"remove,omitempty"`
}
type EventBlockDataviewViewUpdateRelationOperationOfUpdate struct {
	Update *EventBlockDataviewViewUpdateRelationUpdate `protobuf:"bytes,3,opt,name=update,proto3,oneof" json:"update,omitempty"`
}
type EventBlockDataviewViewUpdateRelationOperationOfMove struct {
	Move *EventBlockDataviewViewUpdateRelationMove `protobuf:"bytes,4,opt,name=move,proto3,oneof" json:"move,omitempty"`
}

func (*EventBlockDataviewViewUpdateRelationOperationOfAdd) IsEventBlockDataviewViewUpdateRelationOperation() {
}
func (*EventBlockDataviewViewUpdateRelationOperationOfRemove) IsEventBlockDataviewViewUpdateRelationOperation() {
}
func (*EventBlockDataviewViewUpdateRelationOperationOfUpdate) IsEventBlockDataviewViewUpdateRelationOperation() {
}
func (*EventBlockDataviewViewUpdateRelationOperationOfMove) IsEventBlockDataviewViewUpdateRelationOperation() {
}

func (m *EventBlockDataviewViewUpdateRelation) GetOperation() IsEventBlockDataviewViewUpdateRelationOperation {
	if m != nil {
		return m.Operation
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateRelation) GetAdd() *EventBlockDataviewViewUpdateRelationAdd {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateRelationOperationOfAdd); ok {
		return x.Add
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateRelation) GetRemove() *EventBlockDataviewViewUpdateRelationRemove {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateRelationOperationOfRemove); ok {
		return x.Remove
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateRelation) GetUpdate() *EventBlockDataviewViewUpdateRelationUpdate {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateRelationOperationOfUpdate); ok {
		return x.Update
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateRelation) GetMove() *EventBlockDataviewViewUpdateRelationMove {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateRelationOperationOfMove); ok {
		return x.Move
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EventBlockDataviewViewUpdateRelation) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EventBlockDataviewViewUpdateRelationOperationOfAdd)(nil),
		(*EventBlockDataviewViewUpdateRelationOperationOfRemove)(nil),
		(*EventBlockDataviewViewUpdateRelationOperationOfUpdate)(nil),
		(*EventBlockDataviewViewUpdateRelationOperationOfMove)(nil),
	}
}

type EventBlockDataviewViewUpdateRelationAdd struct {
	AfterId string                                `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Items   []*model.BlockContentDataviewRelation `protobuf:"bytes,2,rep,name=items,proto3" json:"items,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateRelationAdd proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateRelationAdd) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateRelationAdd) GetItems() []*model.BlockContentDataviewRelation {
	if m != nil {
		return m.Items
	}
	return nil
}

type EventBlockDataviewViewUpdateRelationRemove struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateRelationRemove proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateRelationRemove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventBlockDataviewViewUpdateRelationUpdate struct {
	Id   string                              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Item *model.BlockContentDataviewRelation `protobuf:"bytes,2,opt,name=item,proto3" json:"item,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateRelationUpdate proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateRelationUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateRelationUpdate) GetItem() *model.BlockContentDataviewRelation {
	if m != nil {
		return m.Item
	}
	return nil
}

type EventBlockDataviewViewUpdateRelationMove struct {
	AfterId string   `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Ids     []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateRelationMove proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateRelationMove) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateRelationMove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventBlockDataviewViewUpdateSort struct {
	// Types that are valid to be assigned to Operation:
	//
	//	*EventBlockDataviewViewUpdateSortOperationOfAdd
	//	*EventBlockDataviewViewUpdateSortOperationOfRemove
	//	*EventBlockDataviewViewUpdateSortOperationOfUpdate
	//	*EventBlockDataviewViewUpdateSortOperationOfMove
	Operation IsEventBlockDataviewViewUpdateSortOperation `protobuf_oneof:"operation"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateSort proto.InternalMessageInfo

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

type EventBlockDataviewViewUpdateSortOperationOfAdd struct {
	Add *EventBlockDataviewViewUpdateSortAdd `protobuf:"bytes,1,opt,name=add,proto3,oneof" json:"add,omitempty"`
}
type EventBlockDataviewViewUpdateSortOperationOfRemove struct {
	Remove *EventBlockDataviewViewUpdateSortRemove `protobuf:"bytes,2,opt,name=remove,proto3,oneof" json:"remove,omitempty"`
}
type EventBlockDataviewViewUpdateSortOperationOfUpdate struct {
	Update *EventBlockDataviewViewUpdateSortUpdate `protobuf:"bytes,3,opt,name=update,proto3,oneof" json:"update,omitempty"`
}
type EventBlockDataviewViewUpdateSortOperationOfMove struct {
	Move *EventBlockDataviewViewUpdateSortMove `protobuf:"bytes,4,opt,name=move,proto3,oneof" json:"move,omitempty"`
}

func (*EventBlockDataviewViewUpdateSortOperationOfAdd) IsEventBlockDataviewViewUpdateSortOperation() {
}
func (*EventBlockDataviewViewUpdateSortOperationOfRemove) IsEventBlockDataviewViewUpdateSortOperation() {
}
func (*EventBlockDataviewViewUpdateSortOperationOfUpdate) IsEventBlockDataviewViewUpdateSortOperation() {
}
func (*EventBlockDataviewViewUpdateSortOperationOfMove) IsEventBlockDataviewViewUpdateSortOperation() {
}

func (m *EventBlockDataviewViewUpdateSort) GetOperation() IsEventBlockDataviewViewUpdateSortOperation {
	if m != nil {
		return m.Operation
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateSort) GetAdd() *EventBlockDataviewViewUpdateSortAdd {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateSortOperationOfAdd); ok {
		return x.Add
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateSort) GetRemove() *EventBlockDataviewViewUpdateSortRemove {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateSortOperationOfRemove); ok {
		return x.Remove
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateSort) GetUpdate() *EventBlockDataviewViewUpdateSortUpdate {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateSortOperationOfUpdate); ok {
		return x.Update
	}
	return nil
}

func (m *EventBlockDataviewViewUpdateSort) GetMove() *EventBlockDataviewViewUpdateSortMove {
	if x, ok := m.GetOperation().(*EventBlockDataviewViewUpdateSortOperationOfMove); ok {
		return x.Move
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EventBlockDataviewViewUpdateSort) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EventBlockDataviewViewUpdateSortOperationOfAdd)(nil),
		(*EventBlockDataviewViewUpdateSortOperationOfRemove)(nil),
		(*EventBlockDataviewViewUpdateSortOperationOfUpdate)(nil),
		(*EventBlockDataviewViewUpdateSortOperationOfMove)(nil),
	}
}

type EventBlockDataviewViewUpdateSortAdd struct {
	AfterId string                            `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Items   []*model.BlockContentDataviewSort `protobuf:"bytes,2,rep,name=items,proto3" json:"items,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateSortAdd proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateSortAdd) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateSortAdd) GetItems() []*model.BlockContentDataviewSort {
	if m != nil {
		return m.Items
	}
	return nil
}

type EventBlockDataviewViewUpdateSortRemove struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateSortRemove proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateSortRemove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventBlockDataviewViewUpdateSortUpdate struct {
	Id   string                          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Item *model.BlockContentDataviewSort `protobuf:"bytes,2,opt,name=item,proto3" json:"item,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateSortUpdate proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateSortUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateSortUpdate) GetItem() *model.BlockContentDataviewSort {
	if m != nil {
		return m.Item
	}
	return nil
}

type EventBlockDataviewViewUpdateSortMove struct {
	AfterId string   `protobuf:"bytes,1,opt,name=afterId,proto3" json:"afterId,omitempty"`
	Ids     []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewUpdateSortMove proto.InternalMessageInfo

func (m *EventBlockDataviewViewUpdateSortMove) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *EventBlockDataviewViewUpdateSortMove) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type EventBlockDataviewViewDelete struct {
	Id     string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ViewId string `protobuf:"bytes,2,opt,name=viewId,proto3" json:"viewId,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewDelete proto.InternalMessageInfo

func (m *EventBlockDataviewViewDelete) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewDelete) GetViewId() string {
	if m != nil {
		return m.ViewId
	}
	return ""
}

type EventBlockDataviewViewOrder struct {
	Id      string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ViewIds []string `protobuf:"bytes,2,rep,name=viewIds,proto3" json:"viewIds,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewViewOrder proto.InternalMessageInfo

func (m *EventBlockDataviewViewOrder) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewViewOrder) GetViewIds() []string {
	if m != nil {
		return m.ViewIds
	}
	return nil
}

type EventBlockDataviewSourceSet struct {
	Id     string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Source []string `protobuf:"bytes,2,rep,name=source,proto3" json:"source,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewSourceSet proto.InternalMessageInfo

func (m *EventBlockDataviewSourceSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewSourceSet) GetSource() []string {
	if m != nil {
		return m.Source
	}
	return nil
}

type EventBlockDataviewOldRelationDelete struct {
	Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RelationKey string `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewOldRelationDelete proto.InternalMessageInfo

func (m *EventBlockDataviewOldRelationDelete) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewOldRelationDelete) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

// sent when the dataview relation has been changed or added
type EventBlockDataviewOldRelationSet struct {
	Id          string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RelationKey string          `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Relation    *model.Relation `protobuf:"bytes,3,opt,name=relation,proto3" json:"relation,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewOldRelationSet proto.InternalMessageInfo

func (m *EventBlockDataviewOldRelationSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewOldRelationSet) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *EventBlockDataviewOldRelationSet) GetRelation() *model.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

type EventBlockDataviewRelationDelete struct {
	Id           string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RelationKeys []string `protobuf:"bytes,2,rep,name=relationKeys,proto3" json:"relationKeys,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewRelationDelete proto.InternalMessageInfo

func (m *EventBlockDataviewRelationDelete) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewRelationDelete) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	return nil
}

// sent when the dataview relation has been changed or added
type EventBlockDataviewRelationSet struct {
	Id            string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RelationLinks []*model.RelationLink `protobuf:"bytes,2,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewRelationSet proto.InternalMessageInfo

func (m *EventBlockDataviewRelationSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewRelationSet) GetRelationLinks() []*model.RelationLink {
	if m != nil {
		return m.RelationLinks
	}
	return nil
}

type EventBlockDataviewGroupOrderUpdate struct {
	Id         string                                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	GroupOrder *model.BlockContentDataviewGroupOrder `protobuf:"bytes,2,opt,name=groupOrder,proto3" json:"groupOrder,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewGroupOrderUpdate proto.InternalMessageInfo

func (m *EventBlockDataviewGroupOrderUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewGroupOrderUpdate) GetGroupOrder() *model.BlockContentDataviewGroupOrder {
	if m != nil {
		return m.GroupOrder
	}
	return nil
}

type EventBlockDataviewObjectOrderUpdate struct {
	Id           string                           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ViewId       string                           `protobuf:"bytes,2,opt,name=viewId,proto3" json:"viewId,omitempty"`
	GroupId      string                           `protobuf:"bytes,3,opt,name=groupId,proto3" json:"groupId,omitempty"`
	SliceChanges []*EventBlockDataviewSliceChange `protobuf:"bytes,4,rep,name=sliceChanges,proto3" json:"sliceChanges,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewObjectOrderUpdate proto.InternalMessageInfo

func (m *EventBlockDataviewObjectOrderUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewObjectOrderUpdate) GetViewId() string {
	if m != nil {
		return m.ViewId
	}
	return ""
}

func (m *EventBlockDataviewObjectOrderUpdate) GetGroupId() string {
	if m != nil {
		return m.GroupId
	}
	return ""
}

func (m *EventBlockDataviewObjectOrderUpdate) GetSliceChanges() []*EventBlockDataviewSliceChange {
	if m != nil {
		return m.SliceChanges
	}
	return nil
}

type EventBlockDataviewSliceChange struct {
	Op      EventBlockDataviewSliceOperation `protobuf:"varint,1,opt,name=op,proto3,enum=anytype.EventBlockDataviewSliceOperation" json:"op,omitempty"`
	Ids     []string                         `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
	AfterId string                           `protobuf:"bytes,3,opt,name=afterId,proto3" json:"afterId,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewSliceChange proto.InternalMessageInfo

func (m *EventBlockDataviewSliceChange) GetOp() EventBlockDataviewSliceOperation {
	if m != nil {
		return m.Op
	}
	return EventBlockDataview_SliceOperationNone
}

func (m *EventBlockDataviewSliceChange) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *EventBlockDataviewSliceChange) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

type EventBlockDataviewTargetObjectIdSet struct {
	Id             string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	TargetObjectId string `protobuf:"bytes,2,opt,name=targetObjectId,proto3" json:"targetObjectId,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewTargetObjectIdSet proto.InternalMessageInfo

func (m *EventBlockDataviewTargetObjectIdSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewTargetObjectIdSet) GetTargetObjectId() string {
	if m != nil {
		return m.TargetObjectId
	}
	return ""
}

type EventBlockDataviewIsCollectionSet struct {
	Id    string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Value bool   `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_EventBlockDataviewIsCollectionSet proto.InternalMessageInfo

func (m *EventBlockDataviewIsCollectionSet) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventBlockDataviewIsCollectionSet) GetValue() bool {
	if m != nil {
		return m.Value
	}
	return false
}

type EventUser struct {
}

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

var xxx_messageInfo_EventUser proto.InternalMessageInfo

type EventUserBlock struct {
}

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

var xxx_messageInfo_EventUserBlock proto.InternalMessageInfo

// *
//
//	Middleware to front end event message, that will be sent in this
//
// scenario: Precondition: user A opened a block
// 1. User B opens the same block
// 2. User A receives a message about p.1
type EventUserBlockJoin struct {
	Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_EventUserBlockJoin proto.InternalMessageInfo

func (m *EventUserBlockJoin) GetAccount() *EventAccount {
	if m != nil {
		return m.Account
	}
	return nil
}

// *
//
//	Middleware to front end event message, that will be sent in this
//
// scenario: Precondition: user A and user B opened the same block
// 1. User B closes the block
// 2. User A receives a message about p.1
type EventUserBlockLeft struct {
	Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_EventUserBlockLeft proto.InternalMessageInfo

func (m *EventUserBlockLeft) GetAccount() *EventAccount {
	if m != nil {
		return m.Account
	}
	return nil
}

// *
// Middleware to front end event message, that will be sent in this
// scenario: Precondition: user A and user B opened the same block
// 1. User B sets cursor or selects a text region into a text block
// 2. User A receives a message about p.1
type EventUserBlockTextRange struct {
	Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	BlockId string        `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Range   *model.Range  `protobuf:"bytes,3,opt,name=range,proto3" json:"range,omitempty"`
}

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

var xxx_messageInfo_EventUserBlockTextRange proto.InternalMessageInfo

func (m *EventUserBlockTextRange) GetAccount() *EventAccount {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *EventUserBlockTextRange) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *EventUserBlockTextRange) GetRange() *model.Range {
	if m != nil {
		return m.Range
	}
	return nil
}

// *
// Middleware to front end event message, that will be sent in this
// scenario: Precondition: user A and user B opened the same block
// 1. User B selects some inner blocks
// 2. User A receives a message about p.1
type EventUserBlockSelectRange struct {
	Account       *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	BlockIdsArray []string      `protobuf:"bytes,2,rep,name=blockIdsArray,proto3" json:"blockIdsArray,omitempty"`
}

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

var xxx_messageInfo_EventUserBlockSelectRange proto.InternalMessageInfo

func (m *EventUserBlockSelectRange) GetAccount() *EventAccount {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *EventUserBlockSelectRange) GetBlockIdsArray() []string {
	if m != nil {
		return m.BlockIdsArray
	}
	return nil
}

type EventPing struct {
	Index int32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_EventPing proto.InternalMessageInfo

func (m *EventPing) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

type EventProcess struct {
}

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

var xxx_messageInfo_EventProcess proto.InternalMessageInfo

type EventProcessNew struct {
	Process *ModelProcess `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
}

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

var xxx_messageInfo_EventProcessNew proto.InternalMessageInfo

func (m *EventProcessNew) GetProcess() *ModelProcess {
	if m != nil {
		return m.Process
	}
	return nil
}

type EventProcessUpdate struct {
	Process *ModelProcess `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
}

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

var xxx_messageInfo_EventProcessUpdate proto.InternalMessageInfo

func (m *EventProcessUpdate) GetProcess() *ModelProcess {
	if m != nil {
		return m.Process
	}
	return nil
}

type EventProcessDone struct {
	Process *ModelProcess `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
}

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

var xxx_messageInfo_EventProcessDone proto.InternalMessageInfo

func (m *EventProcessDone) GetProcess() *ModelProcess {
	if m != nil {
		return m.Process
	}
	return nil
}

type EventStatus struct {
}

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

var xxx_messageInfo_EventStatus proto.InternalMessageInfo

type EventStatusThread struct {
	Summary  *EventStatusThreadSummary   `protobuf:"bytes,1,opt,name=summary,proto3" json:"summary,omitempty"`
	Cafe     *EventStatusThreadCafe      `protobuf:"bytes,2,opt,name=cafe,proto3" json:"cafe,omitempty"`
	Accounts []*EventStatusThreadAccount `protobuf:"bytes,3,rep,name=accounts,proto3" json:"accounts,omitempty"`
}

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

var xxx_messageInfo_EventStatusThread proto.InternalMessageInfo

func (m *EventStatusThread) GetSummary() *EventStatusThreadSummary {
	if m != nil {
		return m.Summary
	}
	return nil
}

func (m *EventStatusThread) GetCafe() *EventStatusThreadCafe {
	if m != nil {
		return m.Cafe
	}
	return nil
}

func (m *EventStatusThread) GetAccounts() []*EventStatusThreadAccount {
	if m != nil {
		return m.Accounts
	}
	return nil
}

type EventStatusThreadSummary struct {
	Status EventStatusThreadSyncStatus `protobuf:"varint,1,opt,name=status,proto3,enum=anytype.EventStatusThreadSyncStatus" json:"status,omitempty"`
}

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

var xxx_messageInfo_EventStatusThreadSummary proto.InternalMessageInfo

func (m *EventStatusThreadSummary) GetStatus() EventStatusThreadSyncStatus {
	if m != nil {
		return m.Status
	}
	return EventStatusThread_Unknown
}

type EventStatusThreadCafe struct {
	Status          EventStatusThreadSyncStatus     `protobuf:"varint,1,opt,name=status,proto3,enum=anytype.EventStatusThreadSyncStatus" json:"status,omitempty"`
	LastPulled      int64                           `protobuf:"varint,2,opt,name=lastPulled,proto3" json:"lastPulled,omitempty"`
	LastPushSucceed bool                            `protobuf:"varint,3,opt,name=lastPushSucceed,proto3" json:"lastPushSucceed,omitempty"`
	Files           *EventStatusThreadCafePinStatus `protobuf:"bytes,4,opt,name=files,proto3" json:"files,omitempty"`
}

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

var xxx_messageInfo_EventStatusThreadCafe proto.InternalMessageInfo

func (m *EventStatusThreadCafe) GetStatus() EventStatusThreadSyncStatus {
	if m != nil {
		return m.Status
	}
	return EventStatusThread_Unknown
}

func (m *EventStatusThreadCafe) GetLastPulled() int64 {
	if m != nil {
		return m.LastPulled
	}
	return 0
}

func (m *EventStatusThreadCafe) GetLastPushSucceed() bool {
	if m != nil {
		return m.LastPushSucceed
	}
	return false
}

func (m *EventStatusThreadCafe) GetFiles() *EventStatusThreadCafePinStatus {
	if m != nil {
		return m.Files
	}
	return nil
}

type EventStatusThreadCafePinStatus struct {
	Pinning int32 `protobuf:"varint,1,opt,name=pinning,proto3" json:"pinning,omitempty"`
	Pinned  int32 `protobuf:"varint,2,opt,name=pinned,proto3" json:"pinned,omitempty"`
	Failed  int32 `protobuf:"varint,3,opt,name=failed,proto3" json:"failed,omitempty"`
	Updated int64 `protobuf:"varint,4,opt,name=updated,proto3" json:"updated,omitempty"`
}

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

var xxx_messageInfo_EventStatusThreadCafePinStatus proto.InternalMessageInfo

func (m *EventStatusThreadCafePinStatus) GetPinning() int32 {
	if m != nil {
		return m.Pinning
	}
	return 0
}

func (m *EventStatusThreadCafePinStatus) GetPinned() int32 {
	if m != nil {
		return m.Pinned
	}
	return 0
}

func (m *EventStatusThreadCafePinStatus) GetFailed() int32 {
	if m != nil {
		return m.Failed
	}
	return 0
}

func (m *EventStatusThreadCafePinStatus) GetUpdated() int64 {
	if m != nil {
		return m.Updated
	}
	return 0
}

type EventStatusThreadAccount struct {
	Id         string                     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name       string                     `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	ImageHash  string                     `protobuf:"bytes,3,opt,name=imageHash,proto3" json:"imageHash,omitempty"`
	Online     bool                       `protobuf:"varint,4,opt,name=online,proto3" json:"online,omitempty"`
	LastPulled int64                      `protobuf:"varint,5,opt,name=lastPulled,proto3" json:"lastPulled,omitempty"`
	LastEdited int64                      `protobuf:"varint,6,opt,name=lastEdited,proto3" json:"lastEdited,omitempty"`
	Devices    []*EventStatusThreadDevice `protobuf:"bytes,7,rep,name=devices,proto3" json:"devices,omitempty"`
}

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

var xxx_messageInfo_EventStatusThreadAccount proto.InternalMessageInfo

func (m *EventStatusThreadAccount) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

func (m *EventStatusThreadAccount) GetImageHash() string {
	if m != nil {
		return m.ImageHash
	}
	return ""
}

func (m *EventStatusThreadAccount) GetOnline() bool {
	if m != nil {
		return m.Online
	}
	return false
}

func (m *EventStatusThreadAccount) GetLastPulled() int64 {
	if m != nil {
		return m.LastPulled
	}
	return 0
}

func (m *EventStatusThreadAccount) GetLastEdited() int64 {
	if m != nil {
		return m.LastEdited
	}
	return 0
}

func (m *EventStatusThreadAccount) GetDevices() []*EventStatusThreadDevice {
	if m != nil {
		return m.Devices
	}
	return nil
}

type EventStatusThreadDevice struct {
	Name       string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Online     bool   `protobuf:"varint,2,opt,name=online,proto3" json:"online,omitempty"`
	LastPulled int64  `protobuf:"varint,3,opt,name=lastPulled,proto3" json:"lastPulled,omitempty"`
	LastEdited int64  `protobuf:"varint,4,opt,name=lastEdited,proto3" json:"lastEdited,omitempty"`
}

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

var xxx_messageInfo_EventStatusThreadDevice proto.InternalMessageInfo

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

func (m *EventStatusThreadDevice) GetOnline() bool {
	if m != nil {
		return m.Online
	}
	return false
}

func (m *EventStatusThreadDevice) GetLastPulled() int64 {
	if m != nil {
		return m.LastPulled
	}
	return 0
}

func (m *EventStatusThreadDevice) GetLastEdited() int64 {
	if m != nil {
		return m.LastEdited
	}
	return 0
}

type EventFile struct {
}

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

var xxx_messageInfo_EventFile proto.InternalMessageInfo

type EventFileLimitReached struct {
	SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	FileId  string `protobuf:"bytes,2,opt,name=fileId,proto3" json:"fileId,omitempty"`
}

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

var xxx_messageInfo_EventFileLimitReached proto.InternalMessageInfo

func (m *EventFileLimitReached) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

func (m *EventFileLimitReached) GetFileId() string {
	if m != nil {
		return m.FileId
	}
	return ""
}

type EventFileSpaceUsage struct {
	BytesUsage uint64 `protobuf:"varint,1,opt,name=bytesUsage,proto3" json:"bytesUsage,omitempty"`
	SpaceId    string `protobuf:"bytes,2,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
}

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

var xxx_messageInfo_EventFileSpaceUsage proto.InternalMessageInfo

func (m *EventFileSpaceUsage) GetBytesUsage() uint64 {
	if m != nil {
		return m.BytesUsage
	}
	return 0
}

func (m *EventFileSpaceUsage) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

type EventFileLocalUsage struct {
	LocalBytesUsage uint64 `protobuf:"varint,1,opt,name=localBytesUsage,proto3" json:"localBytesUsage,omitempty"`
}

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

var xxx_messageInfo_EventFileLocalUsage proto.InternalMessageInfo

func (m *EventFileLocalUsage) GetLocalBytesUsage() uint64 {
	if m != nil {
		return m.LocalBytesUsage
	}
	return 0
}

type EventFileLimitUpdated struct {
	BytesLimit uint64 `protobuf:"varint,1,opt,name=bytesLimit,proto3" json:"bytesLimit,omitempty"`
}

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

var xxx_messageInfo_EventFileLimitUpdated proto.InternalMessageInfo

func (m *EventFileLimitUpdated) GetBytesLimit() uint64 {
	if m != nil {
		return m.BytesLimit
	}
	return 0
}

type EventMembership struct {
}

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

var xxx_messageInfo_EventMembership proto.InternalMessageInfo

type EventMembershipUpdate struct {
	Data *model.Membership `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_EventMembershipUpdate proto.InternalMessageInfo

func (m *EventMembershipUpdate) GetData() *model.Membership {
	if m != nil {
		return m.Data
	}
	return nil
}

type EventNotification struct {
}

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

var xxx_messageInfo_EventNotification proto.InternalMessageInfo

type EventNotificationSend struct {
	Notification *model.Notification `protobuf:"bytes,1,opt,name=notification,proto3" json:"notification,omitempty"`
}

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

var xxx_messageInfo_EventNotificationSend proto.InternalMessageInfo

func (m *EventNotificationSend) GetNotification() *model.Notification {
	if m != nil {
		return m.Notification
	}
	return nil
}

type EventNotificationUpdate struct {
	Notification *model.Notification `protobuf:"bytes,1,opt,name=notification,proto3" json:"notification,omitempty"`
}

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

var xxx_messageInfo_EventNotificationUpdate proto.InternalMessageInfo

func (m *EventNotificationUpdate) GetNotification() *model.Notification {
	if m != nil {
		return m.Notification
	}
	return nil
}

type EventPayload struct {
}

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

var xxx_messageInfo_EventPayload proto.InternalMessageInfo

type EventPayloadBroadcast struct {
	Payload string `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
}

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

var xxx_messageInfo_EventPayloadBroadcast proto.InternalMessageInfo

func (m *EventPayloadBroadcast) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

type EventSpace struct {
}

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

var xxx_messageInfo_EventSpace proto.InternalMessageInfo

type EventSpaceSyncStatus struct {
}

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

var xxx_messageInfo_EventSpaceSyncStatus proto.InternalMessageInfo

type EventSpaceSyncStatusUpdate struct {
	Id                    string              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Status                EventSpaceStatus    `protobuf:"varint,2,opt,name=status,proto3,enum=anytype.EventSpaceStatus" json:"status,omitempty"`
	Network               EventSpaceNetwork   `protobuf:"varint,3,opt,name=network,proto3,enum=anytype.EventSpaceNetwork" json:"network,omitempty"`
	Error                 EventSpaceSyncError `protobuf:"varint,4,opt,name=error,proto3,enum=anytype.EventSpaceSyncError" json:"error,omitempty"`
	SyncingObjectsCounter int64               `protobuf:"varint,5,opt,name=syncingObjectsCounter,proto3" json:"syncingObjectsCounter,omitempty"`
	NotSyncedFilesCounter int64               `protobuf:"varint,6,opt,name=notSyncedFilesCounter,proto3" json:"notSyncedFilesCounter,omitempty"`
}

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

var xxx_messageInfo_EventSpaceSyncStatusUpdate proto.InternalMessageInfo

func (m *EventSpaceSyncStatusUpdate) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *EventSpaceSyncStatusUpdate) GetStatus() EventSpaceStatus {
	if m != nil {
		return m.Status
	}
	return EventSpace_Synced
}

func (m *EventSpaceSyncStatusUpdate) GetNetwork() EventSpaceNetwork {
	if m != nil {
		return m.Network
	}
	return EventSpace_Anytype
}

func (m *EventSpaceSyncStatusUpdate) GetError() EventSpaceSyncError {
	if m != nil {
		return m.Error
	}
	return EventSpace_Null
}

func (m *EventSpaceSyncStatusUpdate) GetSyncingObjectsCounter() int64 {
	if m != nil {
		return m.SyncingObjectsCounter
	}
	return 0
}

func (m *EventSpaceSyncStatusUpdate) GetNotSyncedFilesCounter() int64 {
	if m != nil {
		return m.NotSyncedFilesCounter
	}
	return 0
}

type EventP2PStatus struct {
}

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

var xxx_messageInfo_EventP2PStatus proto.InternalMessageInfo

type EventP2PStatusUpdate struct {
	SpaceId        string               `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Status         EventP2PStatusStatus `protobuf:"varint,2,opt,name=status,proto3,enum=anytype.EventP2PStatusStatus" json:"status,omitempty"`
	DevicesCounter int64                `protobuf:"varint,3,opt,name=devicesCounter,proto3" json:"devicesCounter,omitempty"`
}

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

var xxx_messageInfo_EventP2PStatusUpdate proto.InternalMessageInfo

func (m *EventP2PStatusUpdate) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

func (m *EventP2PStatusUpdate) GetStatus() EventP2PStatusStatus {
	if m != nil {
		return m.Status
	}
	return EventP2PStatus_NotConnected
}

func (m *EventP2PStatusUpdate) GetDevicesCounter() int64 {
	if m != nil {
		return m.DevicesCounter
	}
	return 0
}

type EventImport struct {
}

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

var xxx_messageInfo_EventImport proto.InternalMessageInfo

type EventImportFinish struct {
	RootCollectionID string           `protobuf:"bytes,1,opt,name=rootCollectionID,proto3" json:"rootCollectionID,omitempty"`
	ObjectsCount     int64            `protobuf:"varint,2,opt,name=objectsCount,proto3" json:"objectsCount,omitempty"`
	ImportType       model.ImportType `protobuf:"varint,3,opt,name=importType,proto3,enum=anytype.model.ImportType" json:"importType,omitempty"`
}

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

var xxx_messageInfo_EventImportFinish proto.InternalMessageInfo

func (m *EventImportFinish) GetRootCollectionID() string {
	if m != nil {
		return m.RootCollectionID
	}
	return ""
}

func (m *EventImportFinish) GetObjectsCount() int64 {
	if m != nil {
		return m.ObjectsCount
	}
	return 0
}

func (m *EventImportFinish) GetImportType() model.ImportType {
	if m != nil {
		return m.ImportType
	}
	return model.Import_Notion
}

type ResponseEvent struct {
	Messages  []*EventMessage `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"`
	ContextId string          `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TraceId   string          `protobuf:"bytes,4,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

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

var xxx_messageInfo_ResponseEvent proto.InternalMessageInfo

func (m *ResponseEvent) GetMessages() []*EventMessage {
	if m != nil {
		return m.Messages
	}
	return nil
}

func (m *ResponseEvent) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *ResponseEvent) GetTraceId() string {
	if m != nil {
		return m.TraceId
	}
	return ""
}

type Model struct {
}

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

var xxx_messageInfo_Model proto.InternalMessageInfo

type ModelProcess struct {
	Id       string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	State    ModelProcessState     `protobuf:"varint,3,opt,name=state,proto3,enum=anytype.ModelProcessState" json:"state,omitempty"`
	Progress *ModelProcessProgress `protobuf:"bytes,4,opt,name=progress,proto3" json:"progress,omitempty"`
	SpaceId  string                `protobuf:"bytes,5,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	// Types that are valid to be assigned to Message:
	//
	//	*ModelProcessMessageOfDropFiles
	//	*ModelProcessMessageOfImport
	//	*ModelProcessMessageOfExport
	//	*ModelProcessMessageOfSaveFile
	//	*ModelProcessMessageOfMigration
	//	*ModelProcessMessageOfPreloadFile
	Message IsModelProcessMessage `protobuf_oneof:"message"`
	Error   string                `protobuf:"bytes,11,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_ModelProcess proto.InternalMessageInfo

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

type ModelProcessMessageOfDropFiles struct {
	DropFiles *ModelProcessDropFiles `protobuf:"bytes,6,opt,name=dropFiles,proto3,oneof" json:"dropFiles,omitempty"`
}
type ModelProcessMessageOfImport struct {
	Import *ModelProcessImport `protobuf:"bytes,7,opt,name=import,proto3,oneof" json:"import,omitempty"`
}
type ModelProcessMessageOfExport struct {
	Export *ModelProcessExport `protobuf:"bytes,8,opt,name=export,proto3,oneof" json:"export,omitempty"`
}
type ModelProcessMessageOfSaveFile struct {
	SaveFile *ModelProcessSaveFile `protobuf:"bytes,9,opt,name=saveFile,proto3,oneof" json:"saveFile,omitempty"`
}
type ModelProcessMessageOfMigration struct {
	Migration *ModelProcessMigration `protobuf:"bytes,10,opt,name=migration,proto3,oneof" json:"migration,omitempty"`
}
type ModelProcessMessageOfPreloadFile struct {
	PreloadFile *ModelProcessPreloadFile `protobuf:"bytes,12,opt,name=preloadFile,proto3,oneof" json:"preloadFile,omitempty"`
}

func (*ModelProcessMessageOfDropFiles) IsModelProcessMessage()   {}
func (*ModelProcessMessageOfImport) IsModelProcessMessage()      {}
func (*ModelProcessMessageOfExport) IsModelProcessMessage()      {}
func (*ModelProcessMessageOfSaveFile) IsModelProcessMessage()    {}
func (*ModelProcessMessageOfMigration) IsModelProcessMessage()   {}
func (*ModelProcessMessageOfPreloadFile) IsModelProcessMessage() {}

func (m *ModelProcess) GetMessage() IsModelProcessMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *ModelProcess) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ModelProcess) GetState() ModelProcessState {
	if m != nil {
		return m.State
	}
	return ModelProcess_None
}

func (m *ModelProcess) GetProgress() *ModelProcessProgress {
	if m != nil {
		return m.Progress
	}
	return nil
}

func (m *ModelProcess) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

func (m *ModelProcess) GetDropFiles() *ModelProcessDropFiles {
	if x, ok := m.GetMessage().(*ModelProcessMessageOfDropFiles); ok {
		return x.DropFiles
	}
	return nil
}

func (m *ModelProcess) GetImport() *ModelProcessImport {
	if x, ok := m.GetMessage().(*ModelProcessMessageOfImport); ok {
		return x.Import
	}
	return nil
}

func (m *ModelProcess) GetExport() *ModelProcessExport {
	if x, ok := m.GetMessage().(*ModelProcessMessageOfExport); ok {
		return x.Export
	}
	return nil
}

func (m *ModelProcess) GetSaveFile() *ModelProcessSaveFile {
	if x, ok := m.GetMessage().(*ModelProcessMessageOfSaveFile); ok {
		return x.SaveFile
	}
	return nil
}

func (m *ModelProcess) GetMigration() *ModelProcessMigration {
	if x, ok := m.GetMessage().(*ModelProcessMessageOfMigration); ok {
		return x.Migration
	}
	return nil
}

func (m *ModelProcess) GetPreloadFile() *ModelProcessPreloadFile {
	if x, ok := m.GetMessage().(*ModelProcessMessageOfPreloadFile); ok {
		return x.PreloadFile
	}
	return nil
}

func (m *ModelProcess) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ModelProcess) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ModelProcessMessageOfDropFiles)(nil),
		(*ModelProcessMessageOfImport)(nil),
		(*ModelProcessMessageOfExport)(nil),
		(*ModelProcessMessageOfSaveFile)(nil),
		(*ModelProcessMessageOfMigration)(nil),
		(*ModelProcessMessageOfPreloadFile)(nil),
	}
}

type ModelProcessDropFiles struct {
}

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

var xxx_messageInfo_ModelProcessDropFiles proto.InternalMessageInfo

type ModelProcessImport struct {
}

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

var xxx_messageInfo_ModelProcessImport proto.InternalMessageInfo

type ModelProcessExport struct {
}

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

var xxx_messageInfo_ModelProcessExport proto.InternalMessageInfo

type ModelProcessSaveFile struct {
}

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

var xxx_messageInfo_ModelProcessSaveFile proto.InternalMessageInfo

type ModelProcessMigration struct {
}

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

var xxx_messageInfo_ModelProcessMigration proto.InternalMessageInfo

type ModelProcessPreloadFile struct {
}

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

var xxx_messageInfo_ModelProcessPreloadFile proto.InternalMessageInfo

type ModelProcessProgress struct {
	Total   int64  `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Done    int64  `protobuf:"varint,2,opt,name=done,proto3" json:"done,omitempty"`
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_ModelProcessProgress proto.InternalMessageInfo

func (m *ModelProcessProgress) GetTotal() int64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *ModelProcessProgress) GetDone() int64 {
	if m != nil {
		return m.Done
	}
	return 0
}

func (m *ModelProcessProgress) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func init() {
	proto.RegisterEnum("anytype.EventBlockDataviewSliceOperation", EventBlockDataviewSliceOperation_name, EventBlockDataviewSliceOperation_value)
	proto.RegisterEnum("anytype.EventStatusThreadSyncStatus", EventStatusThreadSyncStatus_name, EventStatusThreadSyncStatus_value)
	proto.RegisterEnum("anytype.EventSpaceStatus", EventSpaceStatus_name, EventSpaceStatus_value)
	proto.RegisterEnum("anytype.EventSpaceNetwork", EventSpaceNetwork_name, EventSpaceNetwork_value)
	proto.RegisterEnum("anytype.EventSpaceSyncError", EventSpaceSyncError_name, EventSpaceSyncError_value)
	proto.RegisterEnum("anytype.EventP2PStatusStatus", EventP2PStatusStatus_name, EventP2PStatusStatus_value)
	proto.RegisterEnum("anytype.ModelProcessState", ModelProcessState_name, ModelProcessState_value)
	proto.RegisterType((*Event)(nil), "anytype.Event")
	proto.RegisterType((*EventMessage)(nil), "anytype.Event.Message")
	proto.RegisterType((*EventChat)(nil), "anytype.Event.Chat")
	proto.RegisterType((*EventChatAdd)(nil), "anytype.Event.Chat.Add")
	proto.RegisterType((*EventChatDelete)(nil), "anytype.Event.Chat.Delete")
	proto.RegisterType((*EventChatUpdate)(nil), "anytype.Event.Chat.Update")
	proto.RegisterType((*EventChatUpdateReactions)(nil), "anytype.Event.Chat.UpdateReactions")
	proto.RegisterType((*EventChatUpdateMessageReadStatus)(nil), "anytype.Event.Chat.UpdateMessageReadStatus")
	proto.RegisterType((*EventChatUpdateMentionReadStatus)(nil), "anytype.Event.Chat.UpdateMentionReadStatus")
	proto.RegisterType((*EventChatUpdateMessageSyncStatus)(nil), "anytype.Event.Chat.UpdateMessageSyncStatus")
	proto.RegisterType((*EventChatUpdateState)(nil), "anytype.Event.Chat.UpdateState")
	proto.RegisterType((*EventAccount)(nil), "anytype.Event.Account")
	proto.RegisterType((*EventAccountShow)(nil), "anytype.Event.Account.Show")
	proto.RegisterType((*EventAccountDetails)(nil), "anytype.Event.Account.Details")
	proto.RegisterType((*EventAccountConfig)(nil), "anytype.Event.Account.Config")
	proto.RegisterType((*EventAccountConfigUpdate)(nil), "anytype.Event.Account.Config.Update")
	proto.RegisterType((*EventAccountUpdate)(nil), "anytype.Event.Account.Update")
	proto.RegisterType((*EventAccountLinkChallenge)(nil), "anytype.Event.Account.LinkChallenge")
	proto.RegisterType((*EventAccountLinkChallengeClientInfo)(nil), "anytype.Event.Account.LinkChallenge.ClientInfo")
	proto.RegisterType((*EventAccountLinkChallengeHide)(nil), "anytype.Event.Account.LinkChallengeHide")
	proto.RegisterType((*EventObject)(nil), "anytype.Event.Object")
	proto.RegisterType((*EventObjectDetails)(nil), "anytype.Event.Object.Details")
	proto.RegisterType((*EventObjectDetailsAmend)(nil), "anytype.Event.Object.Details.Amend")
	proto.RegisterType((*EventObjectDetailsAmendKeyValue)(nil), "anytype.Event.Object.Details.Amend.KeyValue")
	proto.RegisterType((*EventObjectDetailsSet)(nil), "anytype.Event.Object.Details.Set")
	proto.RegisterType((*EventObjectDetailsUnset)(nil), "anytype.Event.Object.Details.Unset")
	proto.RegisterType((*EventObjectSubscription)(nil), "anytype.Event.Object.Subscription")
	proto.RegisterType((*EventObjectSubscriptionAdd)(nil), "anytype.Event.Object.Subscription.Add")
	proto.RegisterType((*EventObjectSubscriptionRemove)(nil), "anytype.Event.Object.Subscription.Remove")
	proto.RegisterType((*EventObjectSubscriptionPosition)(nil), "anytype.Event.Object.Subscription.Position")
	proto.RegisterType((*EventObjectSubscriptionCounters)(nil), "anytype.Event.Object.Subscription.Counters")
	proto.RegisterType((*EventObjectSubscriptionGroups)(nil), "anytype.Event.Object.Subscription.Groups")
	proto.RegisterType((*EventObjectRelations)(nil), "anytype.Event.Object.Relations")
	proto.RegisterType((*EventObjectRelationsAmend)(nil), "anytype.Event.Object.Relations.Amend")
	proto.RegisterType((*EventObjectRelationsRemove)(nil), "anytype.Event.Object.Relations.Remove")
	proto.RegisterType((*EventObjectRemove)(nil), "anytype.Event.Object.Remove")
	proto.RegisterType((*EventObjectRestrictions)(nil), "anytype.Event.Object.Restrictions")
	proto.RegisterType((*EventObjectRestrictionsSet)(nil), "anytype.Event.Object.Restrictions.Set")
	proto.RegisterType((*EventObjectClose)(nil), "anytype.Event.Object.Close")
	proto.RegisterType((*EventBlock)(nil), "anytype.Event.Block")
	proto.RegisterType((*EventBlockAdd)(nil), "anytype.Event.Block.Add")
	proto.RegisterType((*EventBlockFilesUpload)(nil), "anytype.Event.Block.FilesUpload")
	proto.RegisterType((*EventBlockDelete)(nil), "anytype.Event.Block.Delete")
	proto.RegisterType((*EventBlockMarksInfo)(nil), "anytype.Event.Block.MarksInfo")
	proto.RegisterType((*EventBlockSet)(nil), "anytype.Event.Block.Set")
	proto.RegisterType((*EventBlockSetRelation)(nil), "anytype.Event.Block.Set.Relation")
	proto.RegisterType((*EventBlockSetRelationKey)(nil), "anytype.Event.Block.Set.Relation.Key")
	proto.RegisterType((*EventBlockSetFields)(nil), "anytype.Event.Block.Set.Fields")
	proto.RegisterType((*EventBlockSetChildrenIds)(nil), "anytype.Event.Block.Set.ChildrenIds")
	proto.RegisterType((*EventBlockSetRestrictions)(nil), "anytype.Event.Block.Set.Restrictions")
	proto.RegisterType((*EventBlockSetBackgroundColor)(nil), "anytype.Event.Block.Set.BackgroundColor")
	proto.RegisterType((*EventBlockSetAlign)(nil), "anytype.Event.Block.Set.Align")
	proto.RegisterType((*EventBlockSetVerticalAlign)(nil), "anytype.Event.Block.Set.VerticalAlign")
	proto.RegisterType((*EventBlockSetText)(nil), "anytype.Event.Block.Set.Text")
	proto.RegisterType((*EventBlockSetTextText)(nil), "anytype.Event.Block.Set.Text.Text")
	proto.RegisterType((*EventBlockSetTextStyle)(nil), "anytype.Event.Block.Set.Text.Style")
	proto.RegisterType((*EventBlockSetTextMarks)(nil), "anytype.Event.Block.Set.Text.Marks")
	proto.RegisterType((*EventBlockSetTextChecked)(nil), "anytype.Event.Block.Set.Text.Checked")
	proto.RegisterType((*EventBlockSetTextColor)(nil), "anytype.Event.Block.Set.Text.Color")
	proto.RegisterType((*EventBlockSetTextIconEmoji)(nil), "anytype.Event.Block.Set.Text.IconEmoji")
	proto.RegisterType((*EventBlockSetTextIconImage)(nil), "anytype.Event.Block.Set.Text.IconImage")
	proto.RegisterType((*EventBlockSetLatex)(nil), "anytype.Event.Block.Set.Latex")
	proto.RegisterType((*EventBlockSetLatexText)(nil), "anytype.Event.Block.Set.Latex.Text")
	proto.RegisterType((*EventBlockSetLatexProcessor)(nil), "anytype.Event.Block.Set.Latex.Processor")
	proto.RegisterType((*EventBlockSetDiv)(nil), "anytype.Event.Block.Set.Div")
	proto.RegisterType((*EventBlockSetDivStyle)(nil), "anytype.Event.Block.Set.Div.Style")
	proto.RegisterType((*EventBlockSetFile)(nil), "anytype.Event.Block.Set.File")
	proto.RegisterType((*EventBlockSetFileName)(nil), "anytype.Event.Block.Set.File.Name")
	proto.RegisterType((*EventBlockSetFileWidth)(nil), "anytype.Event.Block.Set.File.Width")
	proto.RegisterType((*EventBlockSetFileState)(nil), "anytype.Event.Block.Set.File.State")
	proto.RegisterType((*EventBlockSetFileType)(nil), "anytype.Event.Block.Set.File.Type")
	proto.RegisterType((*EventBlockSetFileStyle)(nil), "anytype.Event.Block.Set.File.Style")
	proto.RegisterType((*EventBlockSetFileHash)(nil), "anytype.Event.Block.Set.File.Hash")
	proto.RegisterType((*EventBlockSetFileMime)(nil), "anytype.Event.Block.Set.File.Mime")
	proto.RegisterType((*EventBlockSetFileSize)(nil), "anytype.Event.Block.Set.File.Size")
	proto.RegisterType((*EventBlockSetFileTargetObjectId)(nil), "anytype.Event.Block.Set.File.TargetObjectId")
	proto.RegisterType((*EventBlockSetLink)(nil), "anytype.Event.Block.Set.Link")
	proto.RegisterType((*EventBlockSetLinkTargetBlockId)(nil), "anytype.Event.Block.Set.Link.TargetBlockId")
	proto.RegisterType((*EventBlockSetLinkStyle)(nil), "anytype.Event.Block.Set.Link.Style")
	proto.RegisterType((*EventBlockSetLinkFields)(nil), "anytype.Event.Block.Set.Link.Fields")
	proto.RegisterType((*EventBlockSetLinkIconSize)(nil), "anytype.Event.Block.Set.Link.IconSize")
	proto.RegisterType((*EventBlockSetLinkCardStyle)(nil), "anytype.Event.Block.Set.Link.CardStyle")
	proto.RegisterType((*EventBlockSetLinkDescription)(nil), "anytype.Event.Block.Set.Link.Description")
	proto.RegisterType((*EventBlockSetLinkRelations)(nil), "anytype.Event.Block.Set.Link.Relations")
	proto.RegisterType((*EventBlockSetBookmark)(nil), "anytype.Event.Block.Set.Bookmark")
	proto.RegisterType((*EventBlockSetBookmarkUrl)(nil), "anytype.Event.Block.Set.Bookmark.Url")
	proto.RegisterType((*EventBlockSetBookmarkTitle)(nil), "anytype.Event.Block.Set.Bookmark.Title")
	proto.RegisterType((*EventBlockSetBookmarkDescription)(nil), "anytype.Event.Block.Set.Bookmark.Description")
	proto.RegisterType((*EventBlockSetBookmarkImageHash)(nil), "anytype.Event.Block.Set.Bookmark.ImageHash")
	proto.RegisterType((*EventBlockSetBookmarkFaviconHash)(nil), "anytype.Event.Block.Set.Bookmark.FaviconHash")
	proto.RegisterType((*EventBlockSetBookmarkType)(nil), "anytype.Event.Block.Set.Bookmark.Type")
	proto.RegisterType((*EventBlockSetBookmarkTargetObjectId)(nil), "anytype.Event.Block.Set.Bookmark.TargetObjectId")
	proto.RegisterType((*EventBlockSetBookmarkState)(nil), "anytype.Event.Block.Set.Bookmark.State")
	proto.RegisterType((*EventBlockSetTableRow)(nil), "anytype.Event.Block.Set.TableRow")
	proto.RegisterType((*EventBlockSetTableRowIsHeader)(nil), "anytype.Event.Block.Set.TableRow.IsHeader")
	proto.RegisterType((*EventBlockSetWidget)(nil), "anytype.Event.Block.Set.Widget")
	proto.RegisterType((*EventBlockSetWidgetLayout)(nil), "anytype.Event.Block.Set.Widget.Layout")
	proto.RegisterType((*EventBlockSetWidgetLimit)(nil), "anytype.Event.Block.Set.Widget.Limit")
	proto.RegisterType((*EventBlockSetWidgetViewId)(nil), "anytype.Event.Block.Set.Widget.ViewId")
	proto.RegisterType((*EventBlockFill)(nil), "anytype.Event.Block.Fill")
	proto.RegisterType((*EventBlockFillDetails)(nil), "anytype.Event.Block.Fill.Details")
	proto.RegisterType((*EventBlockFillDatabaseRecords)(nil), "anytype.Event.Block.Fill.DatabaseRecords")
	proto.RegisterType((*EventBlockFillFields)(nil), "anytype.Event.Block.Fill.Fields")
	proto.RegisterType((*EventBlockFillChildrenIds)(nil), "anytype.Event.Block.Fill.ChildrenIds")
	proto.RegisterType((*EventBlockFillRestrictions)(nil), "anytype.Event.Block.Fill.Restrictions")
	proto.RegisterType((*EventBlockFillBackgroundColor)(nil), "anytype.Event.Block.Fill.BackgroundColor")
	proto.RegisterType((*EventBlockFillAlign)(nil), "anytype.Event.Block.Fill.Align")
	proto.RegisterType((*EventBlockFillText)(nil), "anytype.Event.Block.Fill.Text")
	proto.RegisterType((*EventBlockFillTextText)(nil), "anytype.Event.Block.Fill.Text.Text")
	proto.RegisterType((*EventBlockFillTextStyle)(nil), "anytype.Event.Block.Fill.Text.Style")
	proto.RegisterType((*EventBlockFillTextMarks)(nil), "anytype.Event.Block.Fill.Text.Marks")
	proto.RegisterType((*EventBlockFillTextChecked)(nil), "anytype.Event.Block.Fill.Text.Checked")
	proto.RegisterType((*EventBlockFillTextColor)(nil), "anytype.Event.Block.Fill.Text.Color")
	proto.RegisterType((*EventBlockFillDiv)(nil), "anytype.Event.Block.Fill.Div")
	proto.RegisterType((*EventBlockFillDivStyle)(nil), "anytype.Event.Block.Fill.Div.Style")
	proto.RegisterType((*EventBlockFillFile)(nil), "anytype.Event.Block.Fill.File")
	proto.RegisterType((*EventBlockFillFileName)(nil), "anytype.Event.Block.Fill.File.Name")
	proto.RegisterType((*EventBlockFillFileWidth)(nil), "anytype.Event.Block.Fill.File.Width")
	proto.RegisterType((*EventBlockFillFileState)(nil), "anytype.Event.Block.Fill.File.State")
	proto.RegisterType((*EventBlockFillFileType)(nil), "anytype.Event.Block.Fill.File.Type")
	proto.RegisterType((*EventBlockFillFileStyle)(nil), "anytype.Event.Block.Fill.File.Style")
	proto.RegisterType((*EventBlockFillFileHash)(nil), "anytype.Event.Block.Fill.File.Hash")
	proto.RegisterType((*EventBlockFillFileMime)(nil), "anytype.Event.Block.Fill.File.Mime")
	proto.RegisterType((*EventBlockFillFileSize)(nil), "anytype.Event.Block.Fill.File.Size")
	proto.RegisterType((*EventBlockFillLink)(nil), "anytype.Event.Block.Fill.Link")
	proto.RegisterType((*EventBlockFillLinkTargetBlockId)(nil), "anytype.Event.Block.Fill.Link.TargetBlockId")
	proto.RegisterType((*EventBlockFillLinkStyle)(nil), "anytype.Event.Block.Fill.Link.Style")
	proto.RegisterType((*EventBlockFillLinkFields)(nil), "anytype.Event.Block.Fill.Link.Fields")
	proto.RegisterType((*EventBlockFillBookmark)(nil), "anytype.Event.Block.Fill.Bookmark")
	proto.RegisterType((*EventBlockFillBookmarkUrl)(nil), "anytype.Event.Block.Fill.Bookmark.Url")
	proto.RegisterType((*EventBlockFillBookmarkTitle)(nil), "anytype.Event.Block.Fill.Bookmark.Title")
	proto.RegisterType((*EventBlockFillBookmarkDescription)(nil), "anytype.Event.Block.Fill.Bookmark.Description")
	proto.RegisterType((*EventBlockFillBookmarkImageHash)(nil), "anytype.Event.Block.Fill.Bookmark.ImageHash")
	proto.RegisterType((*EventBlockFillBookmarkFaviconHash)(nil), "anytype.Event.Block.Fill.Bookmark.FaviconHash")
	proto.RegisterType((*EventBlockFillBookmarkType)(nil), "anytype.Event.Block.Fill.Bookmark.Type")
	proto.RegisterType((*EventBlockFillBookmarkTargetObjectId)(nil), "anytype.Event.Block.Fill.Bookmark.TargetObjectId")
	proto.RegisterType((*EventBlockDataview)(nil), "anytype.Event.Block.Dataview")
	proto.RegisterType((*EventBlockDataviewViewSet)(nil), "anytype.Event.Block.Dataview.ViewSet")
	proto.RegisterType((*EventBlockDataviewViewUpdate)(nil), "anytype.Event.Block.Dataview.ViewUpdate")
	proto.RegisterType((*EventBlockDataviewViewUpdateFields)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Fields")
	proto.RegisterType((*EventBlockDataviewViewUpdateFilter)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Filter")
	proto.RegisterType((*EventBlockDataviewViewUpdateFilterAdd)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Filter.Add")
	proto.RegisterType((*EventBlockDataviewViewUpdateFilterRemove)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Filter.Remove")
	proto.RegisterType((*EventBlockDataviewViewUpdateFilterUpdate)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Filter.Update")
	proto.RegisterType((*EventBlockDataviewViewUpdateFilterMove)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Filter.Move")
	proto.RegisterType((*EventBlockDataviewViewUpdateRelation)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Relation")
	proto.RegisterType((*EventBlockDataviewViewUpdateRelationAdd)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Relation.Add")
	proto.RegisterType((*EventBlockDataviewViewUpdateRelationRemove)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Relation.Remove")
	proto.RegisterType((*EventBlockDataviewViewUpdateRelationUpdate)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Relation.Update")
	proto.RegisterType((*EventBlockDataviewViewUpdateRelationMove)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Relation.Move")
	proto.RegisterType((*EventBlockDataviewViewUpdateSort)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Sort")
	proto.RegisterType((*EventBlockDataviewViewUpdateSortAdd)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Sort.Add")
	proto.RegisterType((*EventBlockDataviewViewUpdateSortRemove)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Sort.Remove")
	proto.RegisterType((*EventBlockDataviewViewUpdateSortUpdate)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Sort.Update")
	proto.RegisterType((*EventBlockDataviewViewUpdateSortMove)(nil), "anytype.Event.Block.Dataview.ViewUpdate.Sort.Move")
	proto.RegisterType((*EventBlockDataviewViewDelete)(nil), "anytype.Event.Block.Dataview.ViewDelete")
	proto.RegisterType((*EventBlockDataviewViewOrder)(nil), "anytype.Event.Block.Dataview.ViewOrder")
	proto.RegisterType((*EventBlockDataviewSourceSet)(nil), "anytype.Event.Block.Dataview.SourceSet")
	proto.RegisterType((*EventBlockDataviewOldRelationDelete)(nil), "anytype.Event.Block.Dataview.OldRelationDelete")
	proto.RegisterType((*EventBlockDataviewOldRelationSet)(nil), "anytype.Event.Block.Dataview.OldRelationSet")
	proto.RegisterType((*EventBlockDataviewRelationDelete)(nil), "anytype.Event.Block.Dataview.RelationDelete")
	proto.RegisterType((*EventBlockDataviewRelationSet)(nil), "anytype.Event.Block.Dataview.RelationSet")
	proto.RegisterType((*EventBlockDataviewGroupOrderUpdate)(nil), "anytype.Event.Block.Dataview.GroupOrderUpdate")
	proto.RegisterType((*EventBlockDataviewObjectOrderUpdate)(nil), "anytype.Event.Block.Dataview.ObjectOrderUpdate")
	proto.RegisterType((*EventBlockDataviewSliceChange)(nil), "anytype.Event.Block.Dataview.SliceChange")
	proto.RegisterType((*EventBlockDataviewTargetObjectIdSet)(nil), "anytype.Event.Block.Dataview.TargetObjectIdSet")
	proto.RegisterType((*EventBlockDataviewIsCollectionSet)(nil), "anytype.Event.Block.Dataview.IsCollectionSet")
	proto.RegisterType((*EventUser)(nil), "anytype.Event.User")
	proto.RegisterType((*EventUserBlock)(nil), "anytype.Event.User.Block")
	proto.RegisterType((*EventUserBlockJoin)(nil), "anytype.Event.User.Block.Join")
	proto.RegisterType((*EventUserBlockLeft)(nil), "anytype.Event.User.Block.Left")
	proto.RegisterType((*EventUserBlockTextRange)(nil), "anytype.Event.User.Block.TextRange")
	proto.RegisterType((*EventUserBlockSelectRange)(nil), "anytype.Event.User.Block.SelectRange")
	proto.RegisterType((*EventPing)(nil), "anytype.Event.Ping")
	proto.RegisterType((*EventProcess)(nil), "anytype.Event.Process")
	proto.RegisterType((*EventProcessNew)(nil), "anytype.Event.Process.New")
	proto.RegisterType((*EventProcessUpdate)(nil), "anytype.Event.Process.Update")
	proto.RegisterType((*EventProcessDone)(nil), "anytype.Event.Process.Done")
	proto.RegisterType((*EventStatus)(nil), "anytype.Event.Status")
	proto.RegisterType((*EventStatusThread)(nil), "anytype.Event.Status.Thread")
	proto.RegisterType((*EventStatusThreadSummary)(nil), "anytype.Event.Status.Thread.Summary")
	proto.RegisterType((*EventStatusThreadCafe)(nil), "anytype.Event.Status.Thread.Cafe")
	proto.RegisterType((*EventStatusThreadCafePinStatus)(nil), "anytype.Event.Status.Thread.Cafe.PinStatus")
	proto.RegisterType((*EventStatusThreadAccount)(nil), "anytype.Event.Status.Thread.Account")
	proto.RegisterType((*EventStatusThreadDevice)(nil), "anytype.Event.Status.Thread.Device")
	proto.RegisterType((*EventFile)(nil), "anytype.Event.File")
	proto.RegisterType((*EventFileLimitReached)(nil), "anytype.Event.File.LimitReached")
	proto.RegisterType((*EventFileSpaceUsage)(nil), "anytype.Event.File.SpaceUsage")
	proto.RegisterType((*EventFileLocalUsage)(nil), "anytype.Event.File.LocalUsage")
	proto.RegisterType((*EventFileLimitUpdated)(nil), "anytype.Event.File.LimitUpdated")
	proto.RegisterType((*EventMembership)(nil), "anytype.Event.Membership")
	proto.RegisterType((*EventMembershipUpdate)(nil), "anytype.Event.Membership.Update")
	proto.RegisterType((*EventNotification)(nil), "anytype.Event.Notification")
	proto.RegisterType((*EventNotificationSend)(nil), "anytype.Event.Notification.Send")
	proto.RegisterType((*EventNotificationUpdate)(nil), "anytype.Event.Notification.Update")
	proto.RegisterType((*EventPayload)(nil), "anytype.Event.Payload")
	proto.RegisterType((*EventPayloadBroadcast)(nil), "anytype.Event.Payload.Broadcast")
	proto.RegisterType((*EventSpace)(nil), "anytype.Event.Space")
	proto.RegisterType((*EventSpaceSyncStatus)(nil), "anytype.Event.Space.SyncStatus")
	proto.RegisterType((*EventSpaceSyncStatusUpdate)(nil), "anytype.Event.Space.SyncStatus.Update")
	proto.RegisterType((*EventP2PStatus)(nil), "anytype.Event.P2PStatus")
	proto.RegisterType((*EventP2PStatusUpdate)(nil), "anytype.Event.P2PStatus.Update")
	proto.RegisterType((*EventImport)(nil), "anytype.Event.Import")
	proto.RegisterType((*EventImportFinish)(nil), "anytype.Event.Import.Finish")
	proto.RegisterType((*ResponseEvent)(nil), "anytype.ResponseEvent")
	proto.RegisterType((*Model)(nil), "anytype.Model")
	proto.RegisterType((*ModelProcess)(nil), "anytype.Model.Process")
	proto.RegisterType((*ModelProcessDropFiles)(nil), "anytype.Model.Process.DropFiles")
	proto.RegisterType((*ModelProcessImport)(nil), "anytype.Model.Process.Import")
	proto.RegisterType((*ModelProcessExport)(nil), "anytype.Model.Process.Export")
	proto.RegisterType((*ModelProcessSaveFile)(nil), "anytype.Model.Process.SaveFile")
	proto.RegisterType((*ModelProcessMigration)(nil), "anytype.Model.Process.Migration")
	proto.RegisterType((*ModelProcessPreloadFile)(nil), "anytype.Model.Process.PreloadFile")
	proto.RegisterType((*ModelProcessProgress)(nil), "anytype.Model.Process.Progress")
}

func init() { proto.RegisterFile("pb/protos/events.proto", fileDescriptor_a966342d378ae5f5) }

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

func (m *Event) 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 *Event) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x22
	}
	if m.Initiator != nil {
		{
			size, err := m.Initiator.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventMessage) 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 *EventMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size := m.Value.Size()
			i -= size
			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}

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

func (m *EventMessageValueOfAccountShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountShow != nil {
		{
			size, err := m.AccountShow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockAdd != nil {
		{
			size, err := m.BlockAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

func (m *EventMessageValueOfBlockSetFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetFields != nil {
		{
			size, err := m.BlockSetFields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetChildrenIds) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetChildrenIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetChildrenIds != nil {
		{
			size, err := m.BlockSetChildrenIds.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetRestrictions != nil {
		{
			size, err := m.BlockSetRestrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetBackgroundColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetBackgroundColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetBackgroundColor != nil {
		{
			size, err := m.BlockSetBackgroundColor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetText != nil {
		{
			size, err := m.BlockSetText.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetFile != nil {
		{
			size, err := m.BlockSetFile.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetLink != nil {
		{
			size, err := m.BlockSetLink.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetBookmark != nil {
		{
			size, err := m.BlockSetBookmark.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetAlign != nil {
		{
			size, err := m.BlockSetAlign.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectDetailsSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectDetailsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectDetailsSet != nil {
		{
			size, err := m.ObjectDetailsSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetDiv != nil {
		{
			size, err := m.BlockSetDiv.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewViewSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewViewSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewViewSet != nil {
		{
			size, err := m.BlockDataviewViewSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewViewDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewViewDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewViewDelete != nil {
		{
			size, err := m.BlockDataviewViewDelete.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetRelation != nil {
		{
			size, err := m.BlockSetRelation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewOldRelationSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewOldRelationSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewOldRelationSet != nil {
		{
			size, err := m.BlockDataviewOldRelationSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewOldRelationDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewOldRelationDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewOldRelationDelete != nil {
		{
			size, err := m.BlockDataviewOldRelationDelete.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetLatex) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetLatex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetLatex != nil {
		{
			size, err := m.BlockSetLatex.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewViewOrder) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewViewOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewViewOrder != nil {
		{
			size, err := m.BlockDataviewViewOrder.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfUserBlockJoin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfUserBlockJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UserBlockJoin != nil {
		{
			size, err := m.UserBlockJoin.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xfa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfUserBlockLeft) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfUserBlockLeft) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UserBlockLeft != nil {
		{
			size, err := m.UserBlockLeft.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfUserBlockSelectRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfUserBlockSelectRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UserBlockSelectRange != nil {
		{
			size, err := m.UserBlockSelectRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfUserBlockTextRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfUserBlockTextRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UserBlockTextRange != nil {
		{
			size, err := m.UserBlockTextRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewSourceSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewSourceSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewSourceSet != nil {
		{
			size, err := m.BlockDataviewSourceSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetVerticalAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetVerticalAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetVerticalAlign != nil {
		{
			size, err := m.BlockSetVerticalAlign.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetTableRow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetTableRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetTableRow != nil {
		{
			size, err := m.BlockSetTableRow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataViewGroupOrderUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataViewGroupOrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataViewGroupOrderUpdate != nil {
		{
			size, err := m.BlockDataViewGroupOrderUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataViewObjectOrderUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataViewObjectOrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataViewObjectOrderUpdate != nil {
		{
			size, err := m.BlockDataViewObjectOrderUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockSetWidget) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockSetWidget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockSetWidget != nil {
		{
			size, err := m.BlockSetWidget.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectDetailsAmend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectDetailsAmend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectDetailsAmend != nil {
		{
			size, err := m.ObjectDetailsAmend.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectDetailsUnset) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectDetailsUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectDetailsUnset != nil {
		{
			size, err := m.ObjectDetailsUnset.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectRelationsAmend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectRelationsAmend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectRelationsAmend != nil {
		{
			size, err := m.ObjectRelationsAmend.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectRelationsRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectRelationsRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectRelationsRemove != nil {
		{
			size, err := m.ObjectRelationsRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectRemove != nil {
		{
			size, err := m.ObjectRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectRestrictionsSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectRestrictionsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectRestrictionsSet != nil {
		{
			size, err := m.ObjectRestrictionsSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfSubscriptionAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfSubscriptionAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SubscriptionAdd != nil {
		{
			size, err := m.SubscriptionAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xe2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfSubscriptionRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfSubscriptionRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SubscriptionRemove != nil {
		{
			size, err := m.SubscriptionRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfSubscriptionPosition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfSubscriptionPosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SubscriptionPosition != nil {
		{
			size, err := m.SubscriptionPosition.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xf2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfSubscriptionCounters) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfSubscriptionCounters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SubscriptionCounters != nil {
		{
			size, err := m.SubscriptionCounters.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xfa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfSubscriptionGroups) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfSubscriptionGroups) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SubscriptionGroups != nil {
		{
			size, err := m.SubscriptionGroups.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfObjectClose) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfObjectClose) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ObjectClose != nil {
		{
			size, err := m.ObjectClose.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfPing) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Ping != nil {
		{
			size, err := m.Ping.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfProcessNew) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfProcessNew) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ProcessNew != nil {
		{
			size, err := m.ProcessNew.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfProcessUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfProcessUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ProcessUpdate != nil {
		{
			size, err := m.ProcessUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfProcessDone) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfProcessDone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ProcessDone != nil {
		{
			size, err := m.ProcessDone.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfThreadStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfThreadStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ThreadStatus != nil {
		{
			size, err := m.ThreadStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xf2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfFileLimitReached) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfFileLimitReached) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FileLimitReached != nil {
		{
			size, err := m.FileLimitReached.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xfa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfFileSpaceUsage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfFileSpaceUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FileSpaceUsage != nil {
		{
			size, err := m.FileSpaceUsage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfFileLocalUsage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfFileLocalUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FileLocalUsage != nil {
		{
			size, err := m.FileLocalUsage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfNotificationSend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfNotificationSend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NotificationSend != nil {
		{
			size, err := m.NotificationSend.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfNotificationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfNotificationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NotificationUpdate != nil {
		{
			size, err := m.NotificationUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfPayloadBroadcast) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfPayloadBroadcast) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PayloadBroadcast != nil {
		{
			size, err := m.PayloadBroadcast.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfMembershipUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfMembershipUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MembershipUpdate != nil {
		{
			size, err := m.MembershipUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfFileLimitUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfFileLimitUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FileLimitUpdated != nil {
		{
			size, err := m.FileLimitUpdated.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfSpaceSyncStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfSpaceSyncStatusUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SpaceSyncStatusUpdate != nil {
		{
			size, err := m.SpaceSyncStatusUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfP2PStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfP2PStatusUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.P2PStatusUpdate != nil {
		{
			size, err := m.P2PStatusUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfImportFinish) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfImportFinish) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ImportFinish != nil {
		{
			size, err := m.ImportFinish.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewRelationSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewRelationSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewRelationSet != nil {
		{
			size, err := m.BlockDataviewRelationSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xda
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewRelationDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewRelationDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewRelationDelete != nil {
		{
			size, err := m.BlockDataviewRelationDelete.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xe2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewViewUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewViewUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewViewUpdate != nil {
		{
			size, err := m.BlockDataviewViewUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewTargetObjectIdSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewTargetObjectIdSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewTargetObjectIdSet != nil {
		{
			size, err := m.BlockDataviewTargetObjectIdSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xf2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfBlockDataviewIsCollectionSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfBlockDataviewIsCollectionSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BlockDataviewIsCollectionSet != nil {
		{
			size, err := m.BlockDataviewIsCollectionSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7
		i--
		dAtA[i] = 0xfa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatAdd != nil {
		{
			size, err := m.ChatAdd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatUpdate != nil {
		{
			size, err := m.ChatUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatUpdateReactions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatUpdateReactions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatUpdateReactions != nil {
		{
			size, err := m.ChatUpdateReactions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatDelete != nil {
		{
			size, err := m.ChatDelete.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatStateUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatStateUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatStateUpdate != nil {
		{
			size, err := m.ChatStateUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatUpdateMessageReadStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatUpdateMessageReadStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatUpdateMessageReadStatus != nil {
		{
			size, err := m.ChatUpdateMessageReadStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatUpdateMentionReadStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatUpdateMentionReadStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatUpdateMentionReadStatus != nil {
		{
			size, err := m.ChatUpdateMentionReadStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfChatUpdateMessageSyncStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfChatUpdateMessageSyncStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ChatUpdateMessageSyncStatus != nil {
		{
			size, err := m.ChatUpdateMessageSyncStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x8
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfAccountDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfAccountDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountDetails != nil {
		{
			size, err := m.AccountDetails.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xc
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfAccountConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfAccountConfigUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountConfigUpdate != nil {
		{
			size, err := m.AccountConfigUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xc
		i--
		dAtA[i] = 0xd2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfAccountUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfAccountUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountUpdate != nil {
		{
			size, err := m.AccountUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xc
		i--
		dAtA[i] = 0xda
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfAccountLinkChallenge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfAccountLinkChallenge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountLinkChallenge != nil {
		{
			size, err := m.AccountLinkChallenge.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xc
		i--
		dAtA[i] = 0xe2
	}
	return len(dAtA) - i, nil
}
func (m *EventMessageValueOfAccountLinkChallengeHide) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMessageValueOfAccountLinkChallengeHide) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountLinkChallengeHide != nil {
		{
			size, err := m.AccountLinkChallengeHide.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xc
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *EventChat) 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 *EventChat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventChatAdd) 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 *EventChatAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AfterOrderId) > 0 {
		i -= len(m.AfterOrderId)
		copy(dAtA[i:], m.AfterOrderId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterOrderId)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Dependencies) > 0 {
		for iNdEx := len(m.Dependencies) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Dependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OrderId) > 0 {
		i -= len(m.OrderId)
		copy(dAtA[i:], m.OrderId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.OrderId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventChatDelete) 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 *EventChatDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventChatUpdate) 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 *EventChatUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventChatUpdateReactions) 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 *EventChatUpdateReactions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatUpdateReactions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Reactions != nil {
		{
			size, err := m.Reactions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventChatUpdateMessageReadStatus) 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 *EventChatUpdateMessageReadStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatUpdateMessageReadStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.IsRead {
		i--
		if m.IsRead {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventChatUpdateMentionReadStatus) 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 *EventChatUpdateMentionReadStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatUpdateMentionReadStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.IsRead {
		i--
		if m.IsRead {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventChatUpdateMessageSyncStatus) 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 *EventChatUpdateMessageSyncStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatUpdateMessageSyncStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.IsSynced {
		i--
		if m.IsSynced {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventChatUpdateState) 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 *EventChatUpdateState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventChatUpdateState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventAccount) 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 *EventAccount) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventAccountShow) 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 *EventAccountShow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventAccountDetails) 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 *EventAccountDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProfileId) > 0 {
		i -= len(m.ProfileId)
		copy(dAtA[i:], m.ProfileId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ProfileId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventAccountConfig) 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 *EventAccountConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventAccountConfigUpdate) 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 *EventAccountConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountConfigUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventAccountUpdate) 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 *EventAccountUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventAccountLinkChallenge) 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 *EventAccountLinkChallenge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountLinkChallenge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Scope != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Scope))
		i--
		dAtA[i] = 0x18
	}
	if m.ClientInfo != nil {
		{
			size, err := m.ClientInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Challenge) > 0 {
		i -= len(m.Challenge)
		copy(dAtA[i:], m.Challenge)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Challenge)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventAccountLinkChallengeClientInfo) 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 *EventAccountLinkChallengeClientInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventAccountLinkChallengeClientInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x22
	}
	if m.SignatureVerified {
		i--
		if m.SignatureVerified {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.ProcessPath) > 0 {
		i -= len(m.ProcessPath)
		copy(dAtA[i:], m.ProcessPath)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ProcessPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProcessName) > 0 {
		i -= len(m.ProcessName)
		copy(dAtA[i:], m.ProcessName)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ProcessName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventAccountLinkChallengeHide) 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 *EventAccountLinkChallengeHide) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventObject) 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 *EventObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventObjectDetails) 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 *EventObjectDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventObjectDetailsAmend) 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 *EventObjectDetailsAmend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectDetailsAmend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Details) > 0 {
		for iNdEx := len(m.Details) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Details[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectDetailsAmendKeyValue) 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 *EventObjectDetailsAmendKeyValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectDetailsAmendKeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectDetailsSet) 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 *EventObjectDetailsSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectDetailsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectDetailsUnset) 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 *EventObjectDetailsUnset) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectDetailsUnset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Keys[iNdEx])
			copy(dAtA[i:], m.Keys[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Keys[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectSubscription) 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 *EventObjectSubscription) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectSubscription) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventObjectSubscriptionAdd) 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 *EventObjectSubscriptionAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectSubscriptionAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectSubscriptionRemove) 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 *EventObjectSubscriptionRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventObjectSubscriptionPosition) 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 *EventObjectSubscriptionPosition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectSubscriptionPosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectSubscriptionCounters) 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 *EventObjectSubscriptionCounters) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectSubscriptionCounters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0x22
	}
	if m.PrevCount != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.PrevCount))
		i--
		dAtA[i] = 0x18
	}
	if m.NextCount != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NextCount))
		i--
		dAtA[i] = 0x10
	}
	if m.Total != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectSubscriptionGroups) 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 *EventObjectSubscriptionGroups) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectSubscriptionGroups) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Remove {
		i--
		if m.Remove {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Group != nil {
		{
			size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectRelations) 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 *EventObjectRelations) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectRelations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventObjectRelationsAmend) 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 *EventObjectRelationsAmend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectRelationsAmend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationLinks) > 0 {
		for iNdEx := len(m.RelationLinks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RelationLinks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectRelationsRemove) 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 *EventObjectRelationsRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectRelationsRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.RelationKeys[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectRemove) 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 *EventObjectRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectRestrictions) 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 *EventObjectRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventObjectRestrictionsSet) 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 *EventObjectRestrictionsSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventObjectRestrictionsSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Restrictions != nil {
		{
			size, err := m.Restrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventObjectClose) 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 *EventObjectClose) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlock) 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 *EventBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventBlockAdd) 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 *EventBlockAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFilesUpload) 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 *EventBlockFilesUpload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFilesUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FilePath) > 0 {
		for iNdEx := len(m.FilePath) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.FilePath[iNdEx])
			copy(dAtA[i:], m.FilePath[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.FilePath[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDelete) 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 *EventBlockDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockMarksInfo) 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 *EventBlockMarksInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockMarksInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MarksInRange) > 0 {
		dAtA97 := make([]byte, len(m.MarksInRange)*10)
		var j96 int
		for _, num := range m.MarksInRange {
			for num >= 1<<7 {
				dAtA97[j96] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j96++
			}
			dAtA97[j96] = uint8(num)
			j96++
		}
		i -= j96
		copy(dAtA[i:], dAtA97[:j96])
		i = encodeVarintEvents(dAtA, i, uint64(j96))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSet) 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 *EventBlockSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventBlockSetRelation) 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 *EventBlockSetRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetRelationKey) 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 *EventBlockSetRelationKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetFields) 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 *EventBlockSetFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetChildrenIds) 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 *EventBlockSetChildrenIds) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetChildrenIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ChildrenIds) > 0 {
		for iNdEx := len(m.ChildrenIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ChildrenIds[iNdEx])
			copy(dAtA[i:], m.ChildrenIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.ChildrenIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetRestrictions) 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 *EventBlockSetRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Restrictions != nil {
		{
			size, err := m.Restrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetBackgroundColor) 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 *EventBlockSetBackgroundColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetAlign) 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 *EventBlockSetAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Align != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Align))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetVerticalAlign) 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 *EventBlockSetVerticalAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetVerticalAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VerticalAlign != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.VerticalAlign))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetText) 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 *EventBlockSetText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IconImage != nil {
		{
			size, err := m.IconImage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.IconEmoji != nil {
		{
			size, err := m.IconEmoji.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Color != nil {
		{
			size, err := m.Color.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Checked != nil {
		{
			size, err := m.Checked.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Marks != nil {
		{
			size, err := m.Marks.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Text != nil {
		{
			size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetTextText) 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 *EventBlockSetTextText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetTextStyle) 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 *EventBlockSetTextStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetTextStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetTextMarks) 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 *EventBlockSetTextMarks) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetTextMarks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetTextChecked) 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 *EventBlockSetTextChecked) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetTextChecked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value {
		i--
		if m.Value {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetTextColor) 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 *EventBlockSetTextColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetTextIconEmoji) 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 *EventBlockSetTextIconEmoji) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetTextIconImage) 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 *EventBlockSetTextIconImage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetLatex) 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 *EventBlockSetLatex) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLatex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Processor != nil {
		{
			size, err := m.Processor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Text != nil {
		{
			size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLatexText) 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 *EventBlockSetLatexText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetLatexProcessor) 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 *EventBlockSetLatexProcessor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLatexProcessor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetDiv) 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 *EventBlockSetDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetDivStyle) 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 *EventBlockSetDivStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetDivStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFile) 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 *EventBlockSetFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TargetObjectId != nil {
		{
			size, err := m.TargetObjectId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Size_ != nil {
		{
			size, err := m.Size_.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Name != nil {
		{
			size, err := m.Name.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Hash != nil {
		{
			size, err := m.Hash.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Mime != nil {
		{
			size, err := m.Mime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != nil {
		{
			size, err := m.Type.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFileName) 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 *EventBlockSetFileName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetFileWidth) 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 *EventBlockSetFileWidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFileWidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFileState) 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 *EventBlockSetFileState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFileState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFileType) 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 *EventBlockSetFileType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFileType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFileStyle) 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 *EventBlockSetFileStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFileStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFileHash) 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 *EventBlockSetFileHash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetFileMime) 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 *EventBlockSetFileMime) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetFileSize) 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 *EventBlockSetFileSize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetFileSize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetFileTargetObjectId) 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 *EventBlockSetFileTargetObjectId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetLink) 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 *EventBlockSetLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relations != nil {
		{
			size, err := m.Relations.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Description != nil {
		{
			size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.CardStyle != nil {
		{
			size, err := m.CardStyle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.IconSize != nil {
		{
			size, err := m.IconSize.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TargetBlockId != nil {
		{
			size, err := m.TargetBlockId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLinkTargetBlockId) 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 *EventBlockSetLinkTargetBlockId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetLinkStyle) 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 *EventBlockSetLinkStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLinkStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLinkFields) 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 *EventBlockSetLinkFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLinkFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLinkIconSize) 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 *EventBlockSetLinkIconSize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLinkIconSize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLinkCardStyle) 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 *EventBlockSetLinkCardStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLinkCardStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLinkDescription) 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 *EventBlockSetLinkDescription) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLinkDescription) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetLinkRelations) 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 *EventBlockSetLinkRelations) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetLinkRelations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Value[iNdEx])
			copy(dAtA[i:], m.Value[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Value[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetBookmark) 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 *EventBlockSetBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.TargetObjectId != nil {
		{
			size, err := m.TargetObjectId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Type != nil {
		{
			size, err := m.Type.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.FaviconHash != nil {
		{
			size, err := m.FaviconHash.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ImageHash != nil {
		{
			size, err := m.ImageHash.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Description != nil {
		{
			size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Title != nil {
		{
			size, err := m.Title.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Url != nil {
		{
			size, err := m.Url.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetBookmarkUrl) 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 *EventBlockSetBookmarkUrl) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetBookmarkTitle) 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 *EventBlockSetBookmarkTitle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetBookmarkDescription) 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 *EventBlockSetBookmarkDescription) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetBookmarkImageHash) 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 *EventBlockSetBookmarkImageHash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetBookmarkFaviconHash) 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 *EventBlockSetBookmarkFaviconHash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetBookmarkType) 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 *EventBlockSetBookmarkType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetBookmarkType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetBookmarkTargetObjectId) 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 *EventBlockSetBookmarkTargetObjectId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockSetBookmarkState) 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 *EventBlockSetBookmarkState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetBookmarkState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetTableRow) 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 *EventBlockSetTableRow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetTableRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsHeader != nil {
		{
			size, err := m.IsHeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetTableRowIsHeader) 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 *EventBlockSetTableRowIsHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetTableRowIsHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value {
		i--
		if m.Value {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetWidget) 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 *EventBlockSetWidget) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetWidget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ViewId != nil {
		{
			size, err := m.ViewId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Limit != nil {
		{
			size, err := m.Limit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Layout != nil {
		{
			size, err := m.Layout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetWidgetLayout) 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 *EventBlockSetWidgetLayout) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetWidgetLayout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetWidgetLimit) 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 *EventBlockSetWidgetLimit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockSetWidgetLimit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockSetWidgetViewId) 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 *EventBlockSetWidgetViewId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFill) 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 *EventBlockFill) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFill) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventBlockFillDetails) 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 *EventBlockFillDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillDatabaseRecords) 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 *EventBlockFillDatabaseRecords) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillDatabaseRecords) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFields) 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 *EventBlockFillFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillChildrenIds) 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 *EventBlockFillChildrenIds) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillChildrenIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ChildrenIds) > 0 {
		for iNdEx := len(m.ChildrenIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ChildrenIds[iNdEx])
			copy(dAtA[i:], m.ChildrenIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.ChildrenIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillRestrictions) 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 *EventBlockFillRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Restrictions != nil {
		{
			size, err := m.Restrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillBackgroundColor) 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 *EventBlockFillBackgroundColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillAlign) 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 *EventBlockFillAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Align != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Align))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillText) 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 *EventBlockFillText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Color != nil {
		{
			size, err := m.Color.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Checked != nil {
		{
			size, err := m.Checked.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Marks != nil {
		{
			size, err := m.Marks.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Text != nil {
		{
			size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillTextText) 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 *EventBlockFillTextText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillTextStyle) 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 *EventBlockFillTextStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillTextStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillTextMarks) 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 *EventBlockFillTextMarks) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillTextMarks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillTextChecked) 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 *EventBlockFillTextChecked) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillTextChecked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value {
		i--
		if m.Value {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillTextColor) 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 *EventBlockFillTextColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillDiv) 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 *EventBlockFillDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillDivStyle) 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 *EventBlockFillDivStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillDivStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFile) 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 *EventBlockFillFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Size_ != nil {
		{
			size, err := m.Size_.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Name != nil {
		{
			size, err := m.Name.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Hash != nil {
		{
			size, err := m.Hash.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Mime != nil {
		{
			size, err := m.Mime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != nil {
		{
			size, err := m.Type.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFileName) 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 *EventBlockFillFileName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillFileWidth) 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 *EventBlockFillFileWidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFileWidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFileState) 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 *EventBlockFillFileState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFileState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFileType) 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 *EventBlockFillFileType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFileType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFileStyle) 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 *EventBlockFillFileStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFileStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillFileHash) 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 *EventBlockFillFileHash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillFileMime) 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 *EventBlockFillFileMime) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillFileSize) 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 *EventBlockFillFileSize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillFileSize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillLink) 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 *EventBlockFillLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Style != nil {
		{
			size, err := m.Style.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TargetBlockId != nil {
		{
			size, err := m.TargetBlockId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillLinkTargetBlockId) 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 *EventBlockFillLinkTargetBlockId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillLinkStyle) 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 *EventBlockFillLinkStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillLinkStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillLinkFields) 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 *EventBlockFillLinkFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillLinkFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillBookmark) 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 *EventBlockFillBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TargetObjectId != nil {
		{
			size, err := m.TargetObjectId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Type != nil {
		{
			size, err := m.Type.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.FaviconHash != nil {
		{
			size, err := m.FaviconHash.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ImageHash != nil {
		{
			size, err := m.ImageHash.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Description != nil {
		{
			size, err := m.Description.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Title != nil {
		{
			size, err := m.Title.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Url != nil {
		{
			size, err := m.Url.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillBookmarkUrl) 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 *EventBlockFillBookmarkUrl) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillBookmarkTitle) 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 *EventBlockFillBookmarkTitle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillBookmarkDescription) 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 *EventBlockFillBookmarkDescription) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillBookmarkImageHash) 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 *EventBlockFillBookmarkImageHash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillBookmarkFaviconHash) 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 *EventBlockFillBookmarkFaviconHash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockFillBookmarkType) 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 *EventBlockFillBookmarkType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockFillBookmarkType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockFillBookmarkTargetObjectId) 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 *EventBlockFillBookmarkTargetObjectId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataview) 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 *EventBlockDataview) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewSet) 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 *EventBlockDataviewViewSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.View != nil {
		{
			size, err := m.View.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdate) 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 *EventBlockDataviewViewUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Sort) > 0 {
		for iNdEx := len(m.Sort) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sort[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Relation) > 0 {
		for iNdEx := len(m.Relation) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relation[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Filter) > 0 {
		for iNdEx := len(m.Filter) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Filter[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateFields) 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 *EventBlockDataviewViewUpdateFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EndRelationKey) > 0 {
		i -= len(m.EndRelationKey)
		copy(dAtA[i:], m.EndRelationKey)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.EndRelationKey)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.DefaultObjectTypeId) > 0 {
		i -= len(m.DefaultObjectTypeId)
		copy(dAtA[i:], m.DefaultObjectTypeId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.DefaultObjectTypeId)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.DefaultTemplateId) > 0 {
		i -= len(m.DefaultTemplateId)
		copy(dAtA[i:], m.DefaultTemplateId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.DefaultTemplateId)))
		i--
		dAtA[i] = 0x52
	}
	if m.PageLimit != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.PageLimit))
		i--
		dAtA[i] = 0x48
	}
	if m.GroupBackgroundColors {
		i--
		if m.GroupBackgroundColors {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.GroupRelationKey) > 0 {
		i -= len(m.GroupRelationKey)
		copy(dAtA[i:], m.GroupRelationKey)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.GroupRelationKey)))
		i--
		dAtA[i] = 0x3a
	}
	if m.CoverFit {
		i--
		if m.CoverFit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.CardSize != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.CardSize))
		i--
		dAtA[i] = 0x28
	}
	if m.HideIcon {
		i--
		if m.HideIcon {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.CoverRelationKey) > 0 {
		i -= len(m.CoverRelationKey)
		copy(dAtA[i:], m.CoverRelationKey)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.CoverRelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateFilter) 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 *EventBlockDataviewViewUpdateFilter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size := m.Operation.Size()
			i -= size
			if _, err := m.Operation.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *EventBlockDataviewViewUpdateFilterOperationOfAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Add != nil {
		{
			size, err := m.Add.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateFilterOperationOfRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFilterOperationOfRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Remove != nil {
		{
			size, err := m.Remove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateFilterOperationOfUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataviewViewUpdateFilterOperationOfMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Move != nil {
		{
			size, err := m.Move.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateFilterAdd) 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 *EventBlockDataviewViewUpdateFilterAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFilterAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateFilterRemove) 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 *EventBlockDataviewViewUpdateFilterRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFilterRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateFilterUpdate) 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 *EventBlockDataviewViewUpdateFilterUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFilterUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateFilterMove) 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 *EventBlockDataviewViewUpdateFilterMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateFilterMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateRelation) 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 *EventBlockDataviewViewUpdateRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size := m.Operation.Size()
			i -= size
			if _, err := m.Operation.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *EventBlockDataviewViewUpdateRelationOperationOfAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Add != nil {
		{
			size, err := m.Add.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateRelationOperationOfRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateRelationOperationOfRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Remove != nil {
		{
			size, err := m.Remove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateRelationOperationOfUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataviewViewUpdateRelationOperationOfMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Move != nil {
		{
			size, err := m.Move.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateRelationAdd) 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 *EventBlockDataviewViewUpdateRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateRelationRemove) 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 *EventBlockDataviewViewUpdateRelationRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateRelationRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateRelationUpdate) 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 *EventBlockDataviewViewUpdateRelationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateRelationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateRelationMove) 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 *EventBlockDataviewViewUpdateRelationMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateRelationMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateSort) 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 *EventBlockDataviewViewUpdateSort) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateSort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Operation != nil {
		{
			size := m.Operation.Size()
			i -= size
			if _, err := m.Operation.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *EventBlockDataviewViewUpdateSortOperationOfAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Add != nil {
		{
			size, err := m.Add.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateSortOperationOfRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateSortOperationOfRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Remove != nil {
		{
			size, err := m.Remove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateSortOperationOfUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataviewViewUpdateSortOperationOfMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Move != nil {
		{
			size, err := m.Move.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *EventBlockDataviewViewUpdateSortAdd) 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 *EventBlockDataviewViewUpdateSortAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateSortAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateSortRemove) 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 *EventBlockDataviewViewUpdateSortRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateSortRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateSortUpdate) 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 *EventBlockDataviewViewUpdateSortUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateSortUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewUpdateSortMove) 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 *EventBlockDataviewViewUpdateSortMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewUpdateSortMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewViewDelete) 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 *EventBlockDataviewViewDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataviewViewOrder) 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 *EventBlockDataviewViewOrder) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewViewOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ViewIds) > 0 {
		for iNdEx := len(m.ViewIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ViewIds[iNdEx])
			copy(dAtA[i:], m.ViewIds[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.ViewIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewSourceSet) 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 *EventBlockDataviewSourceSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewSourceSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Source) > 0 {
		for iNdEx := len(m.Source) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Source[iNdEx])
			copy(dAtA[i:], m.Source[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewOldRelationDelete) 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 *EventBlockDataviewOldRelationDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataviewOldRelationSet) 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 *EventBlockDataviewOldRelationSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewOldRelationSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewRelationDelete) 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 *EventBlockDataviewRelationDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewRelationDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.RelationKeys[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewRelationSet) 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 *EventBlockDataviewRelationSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewRelationSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationLinks) > 0 {
		for iNdEx := len(m.RelationLinks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RelationLinks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewGroupOrderUpdate) 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 *EventBlockDataviewGroupOrderUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewGroupOrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GroupOrder != nil {
		{
			size, err := m.GroupOrder.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewObjectOrderUpdate) 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 *EventBlockDataviewObjectOrderUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewObjectOrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SliceChanges) > 0 {
		for iNdEx := len(m.SliceChanges) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SliceChanges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.GroupId) > 0 {
		i -= len(m.GroupId)
		copy(dAtA[i:], m.GroupId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.GroupId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewSliceChange) 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 *EventBlockDataviewSliceChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewSliceChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Op != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventBlockDataviewTargetObjectIdSet) 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 *EventBlockDataviewTargetObjectIdSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventBlockDataviewIsCollectionSet) 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 *EventBlockDataviewIsCollectionSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventBlockDataviewIsCollectionSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value {
		i--
		if m.Value {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventUser) 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 *EventUser) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventUser) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventUserBlock) 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 *EventUserBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventUserBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventUserBlockJoin) 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 *EventUserBlockJoin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventUserBlockJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventUserBlockLeft) 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 *EventUserBlockLeft) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventUserBlockLeft) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventUserBlockTextRange) 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 *EventUserBlockTextRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventUserBlockTextRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Range != nil {
		{
			size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventUserBlockSelectRange) 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 *EventUserBlockSelectRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventUserBlockSelectRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockIdsArray) > 0 {
		for iNdEx := len(m.BlockIdsArray) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIdsArray[iNdEx])
			copy(dAtA[i:], m.BlockIdsArray[iNdEx])
			i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockIdsArray[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventPing) 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 *EventPing) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventProcess) 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 *EventProcess) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventProcess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventProcessNew) 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 *EventProcessNew) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventProcessNew) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Process != nil {
		{
			size, err := m.Process.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventProcessUpdate) 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 *EventProcessUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventProcessUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Process != nil {
		{
			size, err := m.Process.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventProcessDone) 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 *EventProcessDone) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventProcessDone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Process != nil {
		{
			size, err := m.Process.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventStatus) 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 *EventStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventStatusThread) 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 *EventStatusThread) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatusThread) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Accounts) > 0 {
		for iNdEx := len(m.Accounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Accounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Cafe != nil {
		{
			size, err := m.Cafe.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Summary != nil {
		{
			size, err := m.Summary.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventStatusThreadSummary) 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 *EventStatusThreadSummary) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatusThreadSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventStatusThreadCafe) 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 *EventStatusThreadCafe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatusThreadCafe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Files != nil {
		{
			size, err := m.Files.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.LastPushSucceed {
		i--
		if m.LastPushSucceed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.LastPulled != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.LastPulled))
		i--
		dAtA[i] = 0x10
	}
	if m.Status != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventStatusThreadCafePinStatus) 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 *EventStatusThreadCafePinStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatusThreadCafePinStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Updated != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Updated))
		i--
		dAtA[i] = 0x20
	}
	if m.Failed != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Failed))
		i--
		dAtA[i] = 0x18
	}
	if m.Pinned != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Pinned))
		i--
		dAtA[i] = 0x10
	}
	if m.Pinning != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Pinning))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventStatusThreadAccount) 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 *EventStatusThreadAccount) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatusThreadAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Devices) > 0 {
		for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.LastEdited != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.LastEdited))
		i--
		dAtA[i] = 0x30
	}
	if m.LastPulled != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.LastPulled))
		i--
		dAtA[i] = 0x28
	}
	if m.Online {
		i--
		if m.Online {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.ImageHash) > 0 {
		i -= len(m.ImageHash)
		copy(dAtA[i:], m.ImageHash)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ImageHash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventStatusThreadDevice) 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 *EventStatusThreadDevice) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventStatusThreadDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastEdited != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.LastEdited))
		i--
		dAtA[i] = 0x20
	}
	if m.LastPulled != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.LastPulled))
		i--
		dAtA[i] = 0x18
	}
	if m.Online {
		i--
		if m.Online {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventFile) 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 *EventFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventFileLimitReached) 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 *EventFileLimitReached) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventFileSpaceUsage) 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 *EventFileSpaceUsage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventFileSpaceUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x12
	}
	if m.BytesUsage != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BytesUsage))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventFileLocalUsage) 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 *EventFileLocalUsage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventFileLocalUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LocalBytesUsage != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.LocalBytesUsage))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventFileLimitUpdated) 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 *EventFileLimitUpdated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventFileLimitUpdated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BytesLimit != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.BytesLimit))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventMembership) 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 *EventMembership) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMembership) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventMembershipUpdate) 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 *EventMembershipUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventMembershipUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventNotification) 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 *EventNotification) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventNotification) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventNotificationSend) 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 *EventNotificationSend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventNotificationSend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Notification != nil {
		{
			size, err := m.Notification.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventNotificationUpdate) 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 *EventNotificationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventNotificationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Notification != nil {
		{
			size, err := m.Notification.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventPayload) 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 *EventPayload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventPayloadBroadcast) 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 *EventPayloadBroadcast) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *EventSpace) 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 *EventSpace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSpace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventSpaceSyncStatus) 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 *EventSpaceSyncStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSpaceSyncStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventSpaceSyncStatusUpdate) 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 *EventSpaceSyncStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSpaceSyncStatusUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NotSyncedFilesCounter != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.NotSyncedFilesCounter))
		i--
		dAtA[i] = 0x30
	}
	if m.SyncingObjectsCounter != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.SyncingObjectsCounter))
		i--
		dAtA[i] = 0x28
	}
	if m.Error != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Error))
		i--
		dAtA[i] = 0x20
	}
	if m.Network != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Network))
		i--
		dAtA[i] = 0x18
	}
	if m.Status != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventP2PStatus) 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 *EventP2PStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventP2PStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventP2PStatusUpdate) 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 *EventP2PStatusUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventP2PStatusUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DevicesCounter != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.DevicesCounter))
		i--
		dAtA[i] = 0x18
	}
	if m.Status != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EventImport) 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 *EventImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *EventImportFinish) 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 *EventImportFinish) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventImportFinish) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ImportType != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ImportType))
		i--
		dAtA[i] = 0x18
	}
	if m.ObjectsCount != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.ObjectsCount))
		i--
		dAtA[i] = 0x10
	}
	if len(m.RootCollectionID) > 0 {
		i -= len(m.RootCollectionID)
		copy(dAtA[i:], m.RootCollectionID)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.RootCollectionID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResponseEvent) 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 *ResponseEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResponseEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvents(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Model) 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 *Model) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Model) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcess) 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 *ModelProcess) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Message != nil {
		{
			size := m.Message.Size()
			i -= size
			if _, err := m.Message.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Progress != nil {
		{
			size, err := m.Progress.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.State != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ModelProcessMessageOfDropFiles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DropFiles != nil {
		{
			size, err := m.DropFiles.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *ModelProcessMessageOfImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessMessageOfImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Import != nil {
		{
			size, err := m.Import.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *ModelProcessMessageOfExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessMessageOfExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Export != nil {
		{
			size, err := m.Export.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *ModelProcessMessageOfSaveFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessMessageOfSaveFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SaveFile != nil {
		{
			size, err := m.SaveFile.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *ModelProcessMessageOfMigration) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessMessageOfMigration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Migration != nil {
		{
			size, err := m.Migration.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *ModelProcessMessageOfPreloadFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessMessageOfPreloadFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PreloadFile != nil {
		{
			size, err := m.PreloadFile.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvents(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	return len(dAtA) - i, nil
}
func (m *ModelProcessDropFiles) 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 *ModelProcessDropFiles) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessDropFiles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcessImport) 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 *ModelProcessImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcessExport) 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 *ModelProcessExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcessSaveFile) 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 *ModelProcessSaveFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessSaveFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcessMigration) 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 *ModelProcessMigration) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessMigration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcessPreloadFile) 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 *ModelProcessPreloadFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessPreloadFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ModelProcessProgress) 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 *ModelProcessProgress) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModelProcessProgress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Done != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Done))
		i--
		dAtA[i] = 0x10
	}
	if m.Total != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
	offset -= sovEvents(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for _, e := range m.Messages {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Initiator != nil {
		l = m.Initiator.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		n += m.Value.Size()
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventMessageValueOfAccountShow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountShow != nil {
		l = m.AccountShow.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockAdd != nil {
		l = m.BlockAdd.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDelete != nil {
		l = m.BlockDelete.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfFilesUpload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FilesUpload != nil {
		l = m.FilesUpload.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfMarksInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MarksInfo != nil {
		l = m.MarksInfo.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetFields != nil {
		l = m.BlockSetFields.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetChildrenIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetChildrenIds != nil {
		l = m.BlockSetChildrenIds.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetRestrictions != nil {
		l = m.BlockSetRestrictions.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetBackgroundColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetBackgroundColor != nil {
		l = m.BlockSetBackgroundColor.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetText != nil {
		l = m.BlockSetText.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetFile != nil {
		l = m.BlockSetFile.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetLink != nil {
		l = m.BlockSetLink.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetBookmark != nil {
		l = m.BlockSetBookmark.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetAlign != nil {
		l = m.BlockSetAlign.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectDetailsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectDetailsSet != nil {
		l = m.ObjectDetailsSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetDiv != nil {
		l = m.BlockSetDiv.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewViewSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewViewSet != nil {
		l = m.BlockDataviewViewSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewViewDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewViewDelete != nil {
		l = m.BlockDataviewViewDelete.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetRelation != nil {
		l = m.BlockSetRelation.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewOldRelationSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewOldRelationSet != nil {
		l = m.BlockDataviewOldRelationSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewOldRelationDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewOldRelationDelete != nil {
		l = m.BlockDataviewOldRelationDelete.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetLatex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetLatex != nil {
		l = m.BlockSetLatex.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewViewOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewViewOrder != nil {
		l = m.BlockDataviewViewOrder.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfUserBlockJoin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserBlockJoin != nil {
		l = m.UserBlockJoin.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfUserBlockLeft) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserBlockLeft != nil {
		l = m.UserBlockLeft.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfUserBlockSelectRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserBlockSelectRange != nil {
		l = m.UserBlockSelectRange.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfUserBlockTextRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserBlockTextRange != nil {
		l = m.UserBlockTextRange.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewSourceSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewSourceSet != nil {
		l = m.BlockDataviewSourceSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetVerticalAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetVerticalAlign != nil {
		l = m.BlockSetVerticalAlign.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetTableRow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetTableRow != nil {
		l = m.BlockSetTableRow.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataViewGroupOrderUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataViewGroupOrderUpdate != nil {
		l = m.BlockDataViewGroupOrderUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataViewObjectOrderUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataViewObjectOrderUpdate != nil {
		l = m.BlockDataViewObjectOrderUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockSetWidget) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockSetWidget != nil {
		l = m.BlockSetWidget.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectDetailsAmend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectDetailsAmend != nil {
		l = m.ObjectDetailsAmend.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectDetailsUnset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectDetailsUnset != nil {
		l = m.ObjectDetailsUnset.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectRelationsAmend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectRelationsAmend != nil {
		l = m.ObjectRelationsAmend.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectRelationsRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectRelationsRemove != nil {
		l = m.ObjectRelationsRemove.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectRemove != nil {
		l = m.ObjectRemove.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectRestrictionsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectRestrictionsSet != nil {
		l = m.ObjectRestrictionsSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfSubscriptionAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubscriptionAdd != nil {
		l = m.SubscriptionAdd.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfSubscriptionRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubscriptionRemove != nil {
		l = m.SubscriptionRemove.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfSubscriptionPosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubscriptionPosition != nil {
		l = m.SubscriptionPosition.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfSubscriptionCounters) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubscriptionCounters != nil {
		l = m.SubscriptionCounters.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfSubscriptionGroups) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubscriptionGroups != nil {
		l = m.SubscriptionGroups.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfObjectClose) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectClose != nil {
		l = m.ObjectClose.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfPing) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ping != nil {
		l = m.Ping.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfProcessNew) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessNew != nil {
		l = m.ProcessNew.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfProcessUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessUpdate != nil {
		l = m.ProcessUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfProcessDone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessDone != nil {
		l = m.ProcessDone.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfThreadStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadStatus != nil {
		l = m.ThreadStatus.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfFileLimitReached) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileLimitReached != nil {
		l = m.FileLimitReached.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfFileSpaceUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileSpaceUsage != nil {
		l = m.FileSpaceUsage.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfFileLocalUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileLocalUsage != nil {
		l = m.FileLocalUsage.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfNotificationSend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NotificationSend != nil {
		l = m.NotificationSend.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfNotificationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NotificationUpdate != nil {
		l = m.NotificationUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfPayloadBroadcast) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PayloadBroadcast != nil {
		l = m.PayloadBroadcast.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfMembershipUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MembershipUpdate != nil {
		l = m.MembershipUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfFileLimitUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FileLimitUpdated != nil {
		l = m.FileLimitUpdated.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfSpaceSyncStatusUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SpaceSyncStatusUpdate != nil {
		l = m.SpaceSyncStatusUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfP2PStatusUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.P2PStatusUpdate != nil {
		l = m.P2PStatusUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfImportFinish) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ImportFinish != nil {
		l = m.ImportFinish.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewRelationSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewRelationSet != nil {
		l = m.BlockDataviewRelationSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewRelationDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewRelationDelete != nil {
		l = m.BlockDataviewRelationDelete.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewViewUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewViewUpdate != nil {
		l = m.BlockDataviewViewUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewTargetObjectIdSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewTargetObjectIdSet != nil {
		l = m.BlockDataviewTargetObjectIdSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfBlockDataviewIsCollectionSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockDataviewIsCollectionSet != nil {
		l = m.BlockDataviewIsCollectionSet.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatAdd != nil {
		l = m.ChatAdd.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatUpdate != nil {
		l = m.ChatUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatUpdateReactions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatUpdateReactions != nil {
		l = m.ChatUpdateReactions.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatDelete != nil {
		l = m.ChatDelete.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatStateUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatStateUpdate != nil {
		l = m.ChatStateUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatUpdateMessageReadStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatUpdateMessageReadStatus != nil {
		l = m.ChatUpdateMessageReadStatus.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatUpdateMentionReadStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatUpdateMentionReadStatus != nil {
		l = m.ChatUpdateMentionReadStatus.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfChatUpdateMessageSyncStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChatUpdateMessageSyncStatus != nil {
		l = m.ChatUpdateMessageSyncStatus.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfAccountDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountDetails != nil {
		l = m.AccountDetails.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfAccountConfigUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountConfigUpdate != nil {
		l = m.AccountConfigUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfAccountUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountUpdate != nil {
		l = m.AccountUpdate.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfAccountLinkChallenge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountLinkChallenge != nil {
		l = m.AccountLinkChallenge.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventMessageValueOfAccountLinkChallengeHide) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountLinkChallengeHide != nil {
		l = m.AccountLinkChallengeHide.Size()
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventChat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventChatAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.OrderId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Dependencies) > 0 {
		for _, e := range m.Dependencies {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	l = len(m.AfterOrderId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventChatDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventChatUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventChatUpdateReactions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Reactions != nil {
		l = m.Reactions.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventChatUpdateMessageReadStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.IsRead {
		n += 2
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventChatUpdateMentionReadStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.IsRead {
		n += 2
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventChatUpdateMessageSyncStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.IsSynced {
		n += 2
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventChatUpdateState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventAccountShow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovEvents(uint64(m.Index))
	}
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventAccountDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProfileId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventAccountConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventAccountConfigUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventAccountUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventAccountLinkChallenge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Challenge)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.ClientInfo != nil {
		l = m.ClientInfo.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Scope != 0 {
		n += 1 + sovEvents(uint64(m.Scope))
	}
	return n
}

func (m *EventAccountLinkChallengeClientInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcessName)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ProcessPath)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.SignatureVerified {
		n += 2
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventAccountLinkChallengeHide) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Challenge)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventObjectDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventObjectDetailsAmend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Details) > 0 {
		for _, e := range m.Details {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventObjectDetailsAmendKeyValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObjectDetailsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventObjectDetailsUnset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Keys) > 0 {
		for _, s := range m.Keys {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventObjectSubscription) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventObjectSubscriptionAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObjectSubscriptionRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObjectSubscriptionPosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObjectSubscriptionCounters) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Total != 0 {
		n += 1 + sovEvents(uint64(m.Total))
	}
	if m.NextCount != 0 {
		n += 1 + sovEvents(uint64(m.NextCount))
	}
	if m.PrevCount != 0 {
		n += 1 + sovEvents(uint64(m.PrevCount))
	}
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObjectSubscriptionGroups) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Group != nil {
		l = m.Group.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Remove {
		n += 2
	}
	return n
}

func (m *EventObjectRelations) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventObjectRelationsAmend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.RelationLinks) > 0 {
		for _, e := range m.RelationLinks {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventObjectRelationsRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventObjectRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventObjectRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventObjectRestrictionsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Restrictions != nil {
		l = m.Restrictions.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventObjectClose) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventBlockAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockFilesUpload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.FilePath) > 0 {
		for _, s := range m.FilePath {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockMarksInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.MarksInRange) > 0 {
		l = 0
		for _, e := range m.MarksInRange {
			l += sovEvents(uint64(e))
		}
		n += 1 + sovEvents(uint64(l)) + l
	}
	return n
}

func (m *EventBlockSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventBlockSetRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetRelationKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetChildrenIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.ChildrenIds) > 0 {
		for _, s := range m.ChildrenIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockSetRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Restrictions != nil {
		l = m.Restrictions.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBackgroundColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.BackgroundColor)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Align != 0 {
		n += 1 + sovEvents(uint64(m.Align))
	}
	return n
}

func (m *EventBlockSetVerticalAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.VerticalAlign != 0 {
		n += 1 + sovEvents(uint64(m.VerticalAlign))
	}
	return n
}

func (m *EventBlockSetText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Text != nil {
		l = m.Text.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Marks != nil {
		l = m.Marks.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Checked != nil {
		l = m.Checked.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Color != nil {
		l = m.Color.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.IconEmoji != nil {
		l = m.IconEmoji.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.IconImage != nil {
		l = m.IconImage.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetTextText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetTextStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetTextMarks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetTextChecked) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value {
		n += 2
	}
	return n
}

func (m *EventBlockSetTextColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetTextIconEmoji) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetTextIconImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLatex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Text != nil {
		l = m.Text.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Processor != nil {
		l = m.Processor.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLatexText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLatexProcessor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetDivStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Type != nil {
		l = m.Type.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Mime != nil {
		l = m.Mime.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Hash != nil {
		l = m.Hash.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Name != nil {
		l = m.Name.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Size_ != nil {
		l = m.Size_.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.TargetObjectId != nil {
		l = m.TargetObjectId.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetFileName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetFileWidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetFileState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetFileType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetFileStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetFileHash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetFileMime) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetFileSize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetFileTargetObjectId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.TargetBlockId != nil {
		l = m.TargetBlockId.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.IconSize != nil {
		l = m.IconSize.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.CardStyle != nil {
		l = m.CardStyle.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Description != nil {
		l = m.Description.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Relations != nil {
		l = m.Relations.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLinkTargetBlockId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLinkStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetLinkFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetLinkIconSize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetLinkCardStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetLinkDescription) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetLinkRelations) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Value) > 0 {
		for _, s := range m.Value {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockSetBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Url != nil {
		l = m.Url.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Title != nil {
		l = m.Title.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Description != nil {
		l = m.Description.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.ImageHash != nil {
		l = m.ImageHash.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.FaviconHash != nil {
		l = m.FaviconHash.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Type != nil {
		l = m.Type.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.TargetObjectId != nil {
		l = m.TargetObjectId.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkUrl) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkTitle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkDescription) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkImageHash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkFaviconHash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetBookmarkTargetObjectId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetBookmarkState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetTableRow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.IsHeader != nil {
		l = m.IsHeader.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetTableRowIsHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value {
		n += 2
	}
	return n
}

func (m *EventBlockSetWidget) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Layout != nil {
		l = m.Layout.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Limit != nil {
		l = m.Limit.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.ViewId != nil {
		l = m.ViewId.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockSetWidgetLayout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetWidgetLimit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockSetWidgetViewId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFill) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventBlockFillDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillDatabaseRecords) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockFillFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillChildrenIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.ChildrenIds) > 0 {
		for _, s := range m.ChildrenIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockFillRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Restrictions != nil {
		l = m.Restrictions.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBackgroundColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.BackgroundColor)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Align != 0 {
		n += 1 + sovEvents(uint64(m.Align))
	}
	return n
}

func (m *EventBlockFillText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Text != nil {
		l = m.Text.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Marks != nil {
		l = m.Marks.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Checked != nil {
		l = m.Checked.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Color != nil {
		l = m.Color.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillTextText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillTextStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillTextMarks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillTextChecked) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value {
		n += 2
	}
	return n
}

func (m *EventBlockFillTextColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillDivStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Type != nil {
		l = m.Type.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Mime != nil {
		l = m.Mime.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Hash != nil {
		l = m.Hash.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Name != nil {
		l = m.Name.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Size_ != nil {
		l = m.Size_.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillFileName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillFileWidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillFileState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillFileType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillFileStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillFileHash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillFileMime) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillFileSize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.TargetBlockId != nil {
		l = m.TargetBlockId.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Style != nil {
		l = m.Style.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillLinkTargetBlockId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillLinkStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillLinkFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Url != nil {
		l = m.Url.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Title != nil {
		l = m.Title.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Description != nil {
		l = m.Description.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.ImageHash != nil {
		l = m.ImageHash.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.FaviconHash != nil {
		l = m.FaviconHash.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Type != nil {
		l = m.Type.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.TargetObjectId != nil {
		l = m.TargetObjectId.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmarkUrl) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmarkTitle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmarkDescription) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmarkImageHash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmarkFaviconHash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockFillBookmarkType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovEvents(uint64(m.Value))
	}
	return n
}

func (m *EventBlockFillBookmarkTargetObjectId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataview) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventBlockDataviewViewSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.View != nil {
		l = m.View.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewViewUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Filter) > 0 {
		for _, e := range m.Filter {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Relation) > 0 {
		for _, e := range m.Relation {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if len(m.Sort) > 0 {
		for _, e := range m.Sort {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewViewUpdateFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovEvents(uint64(m.Type))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.CoverRelationKey)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.HideIcon {
		n += 2
	}
	if m.CardSize != 0 {
		n += 1 + sovEvents(uint64(m.CardSize))
	}
	if m.CoverFit {
		n += 2
	}
	l = len(m.GroupRelationKey)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.GroupBackgroundColors {
		n += 2
	}
	if m.PageLimit != 0 {
		n += 1 + sovEvents(uint64(m.PageLimit))
	}
	l = len(m.DefaultTemplateId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.DefaultObjectTypeId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.EndRelationKey)
	if l > 0 {
		n += 2 + l + sovEvents(uint64(l))
	}
	return n
}

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

func (m *EventBlockDataviewViewUpdateFilterOperationOfAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Add != nil {
		l = m.Add.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateFilterOperationOfRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Remove != nil {
		l = m.Remove.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateFilterOperationOfUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Update != nil {
		l = m.Update.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateFilterOperationOfMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Move != nil {
		l = m.Move.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateFilterAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewUpdateFilterRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewUpdateFilterUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Item != nil {
		l = m.Item.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewViewUpdateFilterMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

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

func (m *EventBlockDataviewViewUpdateRelationOperationOfAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Add != nil {
		l = m.Add.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateRelationOperationOfRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Remove != nil {
		l = m.Remove.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateRelationOperationOfUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Update != nil {
		l = m.Update.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateRelationOperationOfMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Move != nil {
		l = m.Move.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewUpdateRelationRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewUpdateRelationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Item != nil {
		l = m.Item.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewViewUpdateRelationMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

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

func (m *EventBlockDataviewViewUpdateSortOperationOfAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Add != nil {
		l = m.Add.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateSortOperationOfRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Remove != nil {
		l = m.Remove.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateSortOperationOfUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Update != nil {
		l = m.Update.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateSortOperationOfMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Move != nil {
		l = m.Move.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *EventBlockDataviewViewUpdateSortAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewUpdateSortRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewUpdateSortUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Item != nil {
		l = m.Item.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewViewUpdateSortMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewViewDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewViewOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.ViewIds) > 0 {
		for _, s := range m.ViewIds {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewSourceSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewOldRelationDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewOldRelationSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewRelationDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewRelationSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.RelationLinks) > 0 {
		for _, e := range m.RelationLinks {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewGroupOrderUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.GroupOrder != nil {
		l = m.GroupOrder.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewObjectOrderUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.GroupId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.SliceChanges) > 0 {
		for _, e := range m.SliceChanges {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventBlockDataviewSliceChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovEvents(uint64(m.Op))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewTargetObjectIdSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.TargetObjectId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventBlockDataviewIsCollectionSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Value {
		n += 2
	}
	return n
}

func (m *EventUser) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventUserBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventUserBlockJoin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventUserBlockLeft) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventUserBlockTextRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventUserBlockSelectRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.BlockIdsArray) > 0 {
		for _, s := range m.BlockIdsArray {
			l = len(s)
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventPing) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovEvents(uint64(m.Index))
	}
	return n
}

func (m *EventProcess) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventProcessNew) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Process != nil {
		l = m.Process.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventProcessUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Process != nil {
		l = m.Process.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventProcessDone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Process != nil {
		l = m.Process.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventStatusThread) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Summary != nil {
		l = m.Summary.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Cafe != nil {
		l = m.Cafe.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	if len(m.Accounts) > 0 {
		for _, e := range m.Accounts {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventStatusThreadSummary) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovEvents(uint64(m.Status))
	}
	return n
}

func (m *EventStatusThreadCafe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovEvents(uint64(m.Status))
	}
	if m.LastPulled != 0 {
		n += 1 + sovEvents(uint64(m.LastPulled))
	}
	if m.LastPushSucceed {
		n += 2
	}
	if m.Files != nil {
		l = m.Files.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventStatusThreadCafePinStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pinning != 0 {
		n += 1 + sovEvents(uint64(m.Pinning))
	}
	if m.Pinned != 0 {
		n += 1 + sovEvents(uint64(m.Pinned))
	}
	if m.Failed != 0 {
		n += 1 + sovEvents(uint64(m.Failed))
	}
	if m.Updated != 0 {
		n += 1 + sovEvents(uint64(m.Updated))
	}
	return n
}

func (m *EventStatusThreadAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.ImageHash)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Online {
		n += 2
	}
	if m.LastPulled != 0 {
		n += 1 + sovEvents(uint64(m.LastPulled))
	}
	if m.LastEdited != 0 {
		n += 1 + sovEvents(uint64(m.LastEdited))
	}
	if len(m.Devices) > 0 {
		for _, e := range m.Devices {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	return n
}

func (m *EventStatusThreadDevice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Online {
		n += 2
	}
	if m.LastPulled != 0 {
		n += 1 + sovEvents(uint64(m.LastPulled))
	}
	if m.LastEdited != 0 {
		n += 1 + sovEvents(uint64(m.LastEdited))
	}
	return n
}

func (m *EventFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventFileLimitReached) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.FileId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventFileSpaceUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BytesUsage != 0 {
		n += 1 + sovEvents(uint64(m.BytesUsage))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventFileLocalUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LocalBytesUsage != 0 {
		n += 1 + sovEvents(uint64(m.LocalBytesUsage))
	}
	return n
}

func (m *EventFileLimitUpdated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BytesLimit != 0 {
		n += 1 + sovEvents(uint64(m.BytesLimit))
	}
	return n
}

func (m *EventMembership) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventMembershipUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventNotification) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventNotificationSend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Notification != nil {
		l = m.Notification.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventNotificationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Notification != nil {
		l = m.Notification.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventPayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventPayloadBroadcast) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventSpace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventSpaceSyncStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventSpaceSyncStatusUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovEvents(uint64(m.Status))
	}
	if m.Network != 0 {
		n += 1 + sovEvents(uint64(m.Network))
	}
	if m.Error != 0 {
		n += 1 + sovEvents(uint64(m.Error))
	}
	if m.SyncingObjectsCounter != 0 {
		n += 1 + sovEvents(uint64(m.SyncingObjectsCounter))
	}
	if m.NotSyncedFilesCounter != 0 {
		n += 1 + sovEvents(uint64(m.NotSyncedFilesCounter))
	}
	return n
}

func (m *EventP2PStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventP2PStatusUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovEvents(uint64(m.Status))
	}
	if m.DevicesCounter != 0 {
		n += 1 + sovEvents(uint64(m.DevicesCounter))
	}
	return n
}

func (m *EventImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EventImportFinish) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RootCollectionID)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.ObjectsCount != 0 {
		n += 1 + sovEvents(uint64(m.ObjectsCount))
	}
	if m.ImportType != 0 {
		n += 1 + sovEvents(uint64(m.ImportType))
	}
	return n
}

func (m *ResponseEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for _, e := range m.Messages {
			l = e.Size()
			n += 1 + l + sovEvents(uint64(l))
		}
	}
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *Model) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcess) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovEvents(uint64(m.State))
	}
	if m.Progress != nil {
		l = m.Progress.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.Message != nil {
		n += m.Message.Size()
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *ModelProcessMessageOfDropFiles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DropFiles != nil {
		l = m.DropFiles.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *ModelProcessMessageOfImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Import != nil {
		l = m.Import.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *ModelProcessMessageOfExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Export != nil {
		l = m.Export.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *ModelProcessMessageOfSaveFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SaveFile != nil {
		l = m.SaveFile.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *ModelProcessMessageOfMigration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Migration != nil {
		l = m.Migration.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *ModelProcessMessageOfPreloadFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PreloadFile != nil {
		l = m.PreloadFile.Size()
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}
func (m *ModelProcessDropFiles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcessImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcessExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcessSaveFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcessMigration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcessPreloadFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ModelProcessProgress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Total != 0 {
		n += 1 + sovEvents(uint64(m.Total))
	}
	if m.Done != 0 {
		n += 1 + sovEvents(uint64(m.Done))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func sovEvents(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvents(x uint64) (n int) {
	return sovEvents(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 ErrIntOverflowEvents
			}
			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 Messages", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Messages = append(m.Messages, &EventMessage{})
			if err := m.Messages[len(m.Messages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Initiator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Initiator == nil {
				m.Initiator = &model.Account{}
			}
			if err := m.Initiator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMessage) 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 ErrIntOverflowEvents
			}
			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: Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountShow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventAccountShow{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfAccountShow{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockAdd{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDelete{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDelete{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilesUpload", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockFilesUpload{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfFilesUpload{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarksInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockMarksInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfMarksInfo{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetFields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetFields{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetFields{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetChildrenIds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetChildrenIds{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetChildrenIds{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetRestrictions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetRestrictions{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetRestrictions{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetBackgroundColor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetBackgroundColor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetBackgroundColor{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetText", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetText{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetText{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetFile", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetFile{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetFile{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetLink", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetLink{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetLink{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetBookmark", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetBookmark{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetBookmark{v}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetAlign", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetAlign{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetAlign{v}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectDetailsSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectDetailsSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectDetailsSet{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetDiv", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetDiv{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetDiv{v}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewViewSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewViewSet{v}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewViewDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewDelete{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewViewDelete{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetRelation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetRelation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetRelation{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewOldRelationSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewOldRelationSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewOldRelationSet{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewOldRelationDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewOldRelationDelete{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewOldRelationDelete{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetLatex", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetLatex{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetLatex{v}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewViewOrder", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewOrder{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewViewOrder{v}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserBlockJoin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventUserBlockJoin{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfUserBlockJoin{v}
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserBlockLeft", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventUserBlockLeft{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfUserBlockLeft{v}
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserBlockSelectRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventUserBlockSelectRange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfUserBlockSelectRange{v}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserBlockTextRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventUserBlockTextRange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfUserBlockTextRange{v}
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewSourceSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewSourceSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewSourceSet{v}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetVerticalAlign", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetVerticalAlign{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetVerticalAlign{v}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetTableRow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetTableRow{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetTableRow{v}
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataViewGroupOrderUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewGroupOrderUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataViewGroupOrderUpdate{v}
			iNdEx = postIndex
		case 39:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataViewObjectOrderUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewObjectOrderUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataViewObjectOrderUpdate{v}
			iNdEx = postIndex
		case 40:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSetWidget", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockSetWidget{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockSetWidget{v}
			iNdEx = postIndex
		case 50:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectDetailsAmend", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectDetailsAmend{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectDetailsAmend{v}
			iNdEx = postIndex
		case 51:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectDetailsUnset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectDetailsUnset{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectDetailsUnset{v}
			iNdEx = postIndex
		case 52:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectRelationsAmend", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectRelationsAmend{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectRelationsAmend{v}
			iNdEx = postIndex
		case 53:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectRelationsRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectRelationsRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectRelationsRemove{v}
			iNdEx = postIndex
		case 54:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectRemove{v}
			iNdEx = postIndex
		case 55:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectRestrictionsSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectRestrictionsSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectRestrictionsSet{v}
			iNdEx = postIndex
		case 60:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectSubscriptionAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfSubscriptionAdd{v}
			iNdEx = postIndex
		case 61:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectSubscriptionRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfSubscriptionRemove{v}
			iNdEx = postIndex
		case 62:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectSubscriptionPosition{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfSubscriptionPosition{v}
			iNdEx = postIndex
		case 63:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionCounters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectSubscriptionCounters{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfSubscriptionCounters{v}
			iNdEx = postIndex
		case 64:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionGroups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectSubscriptionGroups{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfSubscriptionGroups{v}
			iNdEx = postIndex
		case 65:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectClose", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventObjectClose{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfObjectClose{v}
			iNdEx = postIndex
		case 100:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ping", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventPing{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfPing{v}
			iNdEx = postIndex
		case 101:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessNew", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventProcessNew{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfProcessNew{v}
			iNdEx = postIndex
		case 102:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventProcessUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfProcessUpdate{v}
			iNdEx = postIndex
		case 103:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessDone", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventProcessDone{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfProcessDone{v}
			iNdEx = postIndex
		case 110:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventStatusThread{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfThreadStatus{v}
			iNdEx = postIndex
		case 111:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileLimitReached", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventFileLimitReached{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfFileLimitReached{v}
			iNdEx = postIndex
		case 112:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileSpaceUsage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventFileSpaceUsage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfFileSpaceUsage{v}
			iNdEx = postIndex
		case 113:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileLocalUsage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventFileLocalUsage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfFileLocalUsage{v}
			iNdEx = postIndex
		case 114:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotificationSend", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventNotificationSend{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfNotificationSend{v}
			iNdEx = postIndex
		case 115:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotificationUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventNotificationUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfNotificationUpdate{v}
			iNdEx = postIndex
		case 116:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadBroadcast", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventPayloadBroadcast{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfPayloadBroadcast{v}
			iNdEx = postIndex
		case 117:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MembershipUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventMembershipUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfMembershipUpdate{v}
			iNdEx = postIndex
		case 118:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileLimitUpdated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventFileLimitUpdated{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfFileLimitUpdated{v}
			iNdEx = postIndex
		case 119:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceSyncStatusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventSpaceSyncStatusUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfSpaceSyncStatusUpdate{v}
			iNdEx = postIndex
		case 120:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P2PStatusUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventP2PStatusUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfP2PStatusUpdate{v}
			iNdEx = postIndex
		case 121:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImportFinish", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventImportFinish{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfImportFinish{v}
			iNdEx = postIndex
		case 123:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewRelationSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewRelationSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewRelationSet{v}
			iNdEx = postIndex
		case 124:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewRelationDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewRelationDelete{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewRelationDelete{v}
			iNdEx = postIndex
		case 125:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewViewUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewViewUpdate{v}
			iNdEx = postIndex
		case 126:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewTargetObjectIdSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewTargetObjectIdSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewTargetObjectIdSet{v}
			iNdEx = postIndex
		case 127:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockDataviewIsCollectionSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewIsCollectionSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfBlockDataviewIsCollectionSet{v}
			iNdEx = postIndex
		case 128:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatAdd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatAdd{v}
			iNdEx = postIndex
		case 129:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatUpdate{v}
			iNdEx = postIndex
		case 130:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatUpdateReactions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatUpdateReactions{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatUpdateReactions{v}
			iNdEx = postIndex
		case 131:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatDelete{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatDelete{v}
			iNdEx = postIndex
		case 132:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 133:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatStateUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatUpdateState{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatStateUpdate{v}
			iNdEx = postIndex
		case 134:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatUpdateMessageReadStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatUpdateMessageReadStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatUpdateMessageReadStatus{v}
			iNdEx = postIndex
		case 135:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatUpdateMentionReadStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatUpdateMentionReadStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatUpdateMentionReadStatus{v}
			iNdEx = postIndex
		case 136:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatUpdateMessageSyncStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventChatUpdateMessageSyncStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfChatUpdateMessageSyncStatus{v}
			iNdEx = postIndex
		case 201:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventAccountDetails{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfAccountDetails{v}
			iNdEx = postIndex
		case 202:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountConfigUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventAccountConfigUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfAccountConfigUpdate{v}
			iNdEx = postIndex
		case 203:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventAccountUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfAccountUpdate{v}
			iNdEx = postIndex
		case 204:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountLinkChallenge", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventAccountLinkChallenge{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfAccountLinkChallenge{v}
			iNdEx = postIndex
		case 205:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountLinkChallengeHide", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventAccountLinkChallengeHide{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &EventMessageValueOfAccountLinkChallengeHide{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventChat) 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 ErrIntOverflowEvents
			}
			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: Chat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Chat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventChatAdd) 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 ErrIntOverflowEvents
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 OrderId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &model.ChatMessage{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dependencies = append(m.Dependencies, &types.Struct{})
			if err := m.Dependencies[len(m.Dependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterOrderId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterOrderId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventChatUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &model.ChatMessage{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventChatUpdateReactions) 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 ErrIntOverflowEvents
			}
			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: UpdateReactions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateReactions: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Reactions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Reactions == nil {
				m.Reactions = &model.ChatMessageReactions{}
			}
			if err := m.Reactions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccount) 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 ErrIntOverflowEvents
			}
			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: Account: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Account: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountShow) 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 ErrIntOverflowEvents
			}
			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: Show: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Show: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Account == nil {
				m.Account = &model.Account{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountDetails) 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 ErrIntOverflowEvents
			}
			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: Details: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Details: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountConfig) 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 ErrIntOverflowEvents
			}
			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: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountConfigUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &model.AccountConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &model.AccountStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &model.AccountConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &model.AccountStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountLinkChallenge) 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 ErrIntOverflowEvents
			}
			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: LinkChallenge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LinkChallenge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Challenge", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Challenge = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientInfo == nil {
				m.ClientInfo = &EventAccountLinkChallengeClientInfo{}
			}
			if err := m.ClientInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
			}
			m.Scope = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Scope |= model.AccountAuthLocalApiScope(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventAccountLinkChallengeClientInfo) 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 ErrIntOverflowEvents
			}
			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: ClientInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClientInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignatureVerified", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SignatureVerified = bool(v != 0)
		case 4:
			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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObject) 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 ErrIntOverflowEvents
			}
			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: Object: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Object: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectDetails) 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 ErrIntOverflowEvents
			}
			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: Details: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Details: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectDetailsAmend) 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 ErrIntOverflowEvents
			}
			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: Amend: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Amend: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Details = append(m.Details, &EventObjectDetailsAmendKeyValue{})
			if err := m.Details[len(m.Details)-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 SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectDetailsAmendKeyValue) 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 ErrIntOverflowEvents
			}
			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: KeyValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeyValue: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &types.Value{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectDetailsSet) 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 ErrIntOverflowEvents
			}
			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: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectDetailsUnset) 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 ErrIntOverflowEvents
			}
			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: Unset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Unset: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Keys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectSubscription) 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 ErrIntOverflowEvents
			}
			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: Subscription: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Subscription: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectSubscriptionAdd) 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 ErrIntOverflowEvents
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectSubscriptionPosition) 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 ErrIntOverflowEvents
			}
			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: Position: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Position: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectSubscriptionCounters) 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 ErrIntOverflowEvents
			}
			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: Counters: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Counters: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextCount", wireType)
			}
			m.NextCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevCount", wireType)
			}
			m.PrevCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrevCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectSubscriptionGroups) 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 ErrIntOverflowEvents
			}
			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: Groups: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Groups: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Group == nil {
				m.Group = &model.BlockContentDataviewGroup{}
			}
			if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Remove = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectRelations) 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 ErrIntOverflowEvents
			}
			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: Relations: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relations: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectRelationsAmend) 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 ErrIntOverflowEvents
			}
			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: Amend: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Amend: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 RelationLinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationLinks = append(m.RelationLinks, &model.RelationLink{})
			if err := m.RelationLinks[len(m.RelationLinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectRestrictions) 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 ErrIntOverflowEvents
			}
			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: Restrictions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Restrictions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectRestrictionsSet) 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 ErrIntOverflowEvents
			}
			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: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Restrictions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restrictions == nil {
				m.Restrictions = &model.Restrictions{}
			}
			if err := m.Restrictions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventObjectClose) 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 ErrIntOverflowEvents
			}
			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: Close: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Close: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlock) 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 ErrIntOverflowEvents
			}
			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: Block: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockAdd) 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 ErrIntOverflowEvents
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Blocks = append(m.Blocks, &model.Block{})
			if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockMarksInfo) 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 ErrIntOverflowEvents
			}
			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: MarksInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MarksInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v model.BlockContentTextMarkType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvents
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= model.BlockContentTextMarkType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MarksInRange = append(m.MarksInRange, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvents
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEvents
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthEvents
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.MarksInRange) == 0 {
					m.MarksInRange = make([]model.BlockContentTextMarkType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v model.BlockContentTextMarkType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEvents
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= model.BlockContentTextMarkType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MarksInRange = append(m.MarksInRange, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MarksInRange", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSet) 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 ErrIntOverflowEvents
			}
			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: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetRelation) 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 ErrIntOverflowEvents
			}
			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: Relation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relation: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &EventBlockSetRelationKey{}
			}
			if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFields) 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 ErrIntOverflowEvents
			}
			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: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fields == nil {
				m.Fields = &types.Struct{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetRestrictions) 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 ErrIntOverflowEvents
			}
			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: Restrictions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Restrictions: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Restrictions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restrictions == nil {
				m.Restrictions = &model.BlockRestrictions{}
			}
			if err := m.Restrictions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetAlign) 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 ErrIntOverflowEvents
			}
			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: Align: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Align: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Align", wireType)
			}
			m.Align = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Align |= model.BlockAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetVerticalAlign) 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 ErrIntOverflowEvents
			}
			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: VerticalAlign: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerticalAlign: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VerticalAlign", wireType)
			}
			m.VerticalAlign = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VerticalAlign |= model.BlockVerticalAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetText) 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 ErrIntOverflowEvents
			}
			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: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Text", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Text == nil {
				m.Text = &EventBlockSetTextText{}
			}
			if err := m.Text.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockSetTextStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Marks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Marks == nil {
				m.Marks = &EventBlockSetTextMarks{}
			}
			if err := m.Marks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Checked == nil {
				m.Checked = &EventBlockSetTextChecked{}
			}
			if err := m.Checked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Color == nil {
				m.Color = &EventBlockSetTextColor{}
			}
			if err := m.Color.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEmoji", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IconEmoji == nil {
				m.IconEmoji = &EventBlockSetTextIconEmoji{}
			}
			if err := m.IconEmoji.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconImage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IconImage == nil {
				m.IconImage = &EventBlockSetTextIconImage{}
			}
			if err := m.IconImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetTextStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetTextMarks) 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 ErrIntOverflowEvents
			}
			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: Marks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Marks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &model.BlockContentTextMarks{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetTextChecked) 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 ErrIntOverflowEvents
			}
			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: Checked: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Checked: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLatex) 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 ErrIntOverflowEvents
			}
			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: Latex: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Latex: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Text", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Text == nil {
				m.Text = &EventBlockSetLatexText{}
			}
			if err := m.Text.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Processor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Processor == nil {
				m.Processor = &EventBlockSetLatexProcessor{}
			}
			if err := m.Processor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLatexProcessor) 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 ErrIntOverflowEvents
			}
			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: Processor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Processor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentLatexProcessor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetDiv) 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 ErrIntOverflowEvents
			}
			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: Div: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Div: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockSetDivStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetDivStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentDivStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFile) 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 ErrIntOverflowEvents
			}
			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: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Type == nil {
				m.Type = &EventBlockSetFileType{}
			}
			if err := m.Type.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &EventBlockSetFileState{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Mime == nil {
				m.Mime = &EventBlockSetFileMime{}
			}
			if err := m.Mime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Hash == nil {
				m.Hash = &EventBlockSetFileHash{}
			}
			if err := m.Hash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Name == nil {
				m.Name = &EventBlockSetFileName{}
			}
			if err := m.Name.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Size_ == nil {
				m.Size_ = &EventBlockSetFileSize{}
			}
			if err := m.Size_.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockSetFileStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetObjectId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetObjectId == nil {
				m.TargetObjectId = &EventBlockSetFileTargetObjectId{}
			}
			if err := m.TargetObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFileWidth) 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 ErrIntOverflowEvents
			}
			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: Width: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Width: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFileState) 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 ErrIntOverflowEvents
			}
			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: State: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentFileState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFileType) 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 ErrIntOverflowEvents
			}
			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: Type: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Type: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentFileType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFileStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentFileStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetFileSize) 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 ErrIntOverflowEvents
			}
			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: Size: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Size: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLink) 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 ErrIntOverflowEvents
			}
			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: Link: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Link: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 TargetBlockId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetBlockId == nil {
				m.TargetBlockId = &EventBlockSetLinkTargetBlockId{}
			}
			if err := m.TargetBlockId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockSetLinkStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fields == nil {
				m.Fields = &EventBlockSetLinkFields{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IconSize == nil {
				m.IconSize = &EventBlockSetLinkIconSize{}
			}
			if err := m.IconSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CardStyle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CardStyle == nil {
				m.CardStyle = &EventBlockSetLinkCardStyle{}
			}
			if err := m.CardStyle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Description == nil {
				m.Description = &EventBlockSetLinkDescription{}
			}
			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relations == nil {
				m.Relations = &EventBlockSetLinkRelations{}
			}
			if err := m.Relations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLinkStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentLinkStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLinkFields) 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 ErrIntOverflowEvents
			}
			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: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &types.Struct{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLinkIconSize) 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 ErrIntOverflowEvents
			}
			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: IconSize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IconSize: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentLinkIconSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLinkCardStyle) 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 ErrIntOverflowEvents
			}
			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: CardStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CardStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentLinkCardStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetLinkDescription) 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 ErrIntOverflowEvents
			}
			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: Description: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Description: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentLinkDescription(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetBookmark) 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 ErrIntOverflowEvents
			}
			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: Bookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bookmark: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Url", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Url == nil {
				m.Url = &EventBlockSetBookmarkUrl{}
			}
			if err := m.Url.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Title == nil {
				m.Title = &EventBlockSetBookmarkTitle{}
			}
			if err := m.Title.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Description == nil {
				m.Description = &EventBlockSetBookmarkDescription{}
			}
			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageHash", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImageHash == nil {
				m.ImageHash = &EventBlockSetBookmarkImageHash{}
			}
			if err := m.ImageHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FaviconHash", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FaviconHash == nil {
				m.FaviconHash = &EventBlockSetBookmarkFaviconHash{}
			}
			if err := m.FaviconHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Type == nil {
				m.Type = &EventBlockSetBookmarkType{}
			}
			if err := m.Type.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetObjectId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetObjectId == nil {
				m.TargetObjectId = &EventBlockSetBookmarkTargetObjectId{}
			}
			if err := m.TargetObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &EventBlockSetBookmarkState{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetBookmarkType) 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 ErrIntOverflowEvents
			}
			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: Type: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Type: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.LinkPreviewType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetBookmarkState) 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 ErrIntOverflowEvents
			}
			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: State: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentBookmarkState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetTableRow) 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 ErrIntOverflowEvents
			}
			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: TableRow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableRow: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 IsHeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IsHeader == nil {
				m.IsHeader = &EventBlockSetTableRowIsHeader{}
			}
			if err := m.IsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetTableRowIsHeader) 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 ErrIntOverflowEvents
			}
			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: IsHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IsHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetWidget) 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 ErrIntOverflowEvents
			}
			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: Widget: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Widget: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Layout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Layout == nil {
				m.Layout = &EventBlockSetWidgetLayout{}
			}
			if err := m.Layout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Limit == nil {
				m.Limit = &EventBlockSetWidgetLimit{}
			}
			if err := m.Limit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ViewId == nil {
				m.ViewId = &EventBlockSetWidgetViewId{}
			}
			if err := m.ViewId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetWidgetLayout) 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 ErrIntOverflowEvents
			}
			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: Layout: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Layout: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentWidgetLayout(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockSetWidgetLimit) 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 ErrIntOverflowEvents
			}
			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: Limit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Limit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFill) 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 ErrIntOverflowEvents
			}
			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: Fill: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fill: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillDetails) 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 ErrIntOverflowEvents
			}
			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: Details: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Details: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillDatabaseRecords) 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 ErrIntOverflowEvents
			}
			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: DatabaseRecords: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatabaseRecords: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Records = append(m.Records, &types.Struct{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFields) 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 ErrIntOverflowEvents
			}
			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: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fields == nil {
				m.Fields = &types.Struct{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillRestrictions) 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 ErrIntOverflowEvents
			}
			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: Restrictions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Restrictions: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Restrictions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restrictions == nil {
				m.Restrictions = &model.BlockRestrictions{}
			}
			if err := m.Restrictions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillAlign) 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 ErrIntOverflowEvents
			}
			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: Align: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Align: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Align", wireType)
			}
			m.Align = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Align |= model.BlockAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillText) 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 ErrIntOverflowEvents
			}
			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: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Text", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Text == nil {
				m.Text = &EventBlockFillTextText{}
			}
			if err := m.Text.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockFillTextStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Marks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Marks == nil {
				m.Marks = &EventBlockFillTextMarks{}
			}
			if err := m.Marks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Checked == nil {
				m.Checked = &EventBlockFillTextChecked{}
			}
			if err := m.Checked.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Color == nil {
				m.Color = &EventBlockFillTextColor{}
			}
			if err := m.Color.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillTextStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillTextMarks) 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 ErrIntOverflowEvents
			}
			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: Marks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Marks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &model.BlockContentTextMarks{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillTextChecked) 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 ErrIntOverflowEvents
			}
			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: Checked: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Checked: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillDiv) 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 ErrIntOverflowEvents
			}
			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: Div: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Div: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockFillDivStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillDivStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentDivStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFile) 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 ErrIntOverflowEvents
			}
			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: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Type == nil {
				m.Type = &EventBlockFillFileType{}
			}
			if err := m.Type.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &EventBlockFillFileState{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Mime == nil {
				m.Mime = &EventBlockFillFileMime{}
			}
			if err := m.Mime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Hash == nil {
				m.Hash = &EventBlockFillFileHash{}
			}
			if err := m.Hash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Name == nil {
				m.Name = &EventBlockFillFileName{}
			}
			if err := m.Name.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Size_ == nil {
				m.Size_ = &EventBlockFillFileSize{}
			}
			if err := m.Size_.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockFillFileStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFileWidth) 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 ErrIntOverflowEvents
			}
			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: Width: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Width: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFileState) 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 ErrIntOverflowEvents
			}
			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: State: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentFileState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFileType) 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 ErrIntOverflowEvents
			}
			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: Type: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Type: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentFileType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFileStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentFileStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillFileSize) 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 ErrIntOverflowEvents
			}
			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: Size: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Size: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillLink) 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 ErrIntOverflowEvents
			}
			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: Link: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Link: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 TargetBlockId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetBlockId == nil {
				m.TargetBlockId = &EventBlockFillLinkTargetBlockId{}
			}
			if err := m.TargetBlockId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Style == nil {
				m.Style = &EventBlockFillLinkStyle{}
			}
			if err := m.Style.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fields == nil {
				m.Fields = &EventBlockFillLinkFields{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillLinkStyle) 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 ErrIntOverflowEvents
			}
			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: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.BlockContentLinkStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillLinkFields) 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 ErrIntOverflowEvents
			}
			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: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &types.Struct{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillBookmark) 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 ErrIntOverflowEvents
			}
			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: Bookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bookmark: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Url", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Url == nil {
				m.Url = &EventBlockFillBookmarkUrl{}
			}
			if err := m.Url.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Title == nil {
				m.Title = &EventBlockFillBookmarkTitle{}
			}
			if err := m.Title.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Description == nil {
				m.Description = &EventBlockFillBookmarkDescription{}
			}
			if err := m.Description.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageHash", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ImageHash == nil {
				m.ImageHash = &EventBlockFillBookmarkImageHash{}
			}
			if err := m.ImageHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FaviconHash", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FaviconHash == nil {
				m.FaviconHash = &EventBlockFillBookmarkFaviconHash{}
			}
			if err := m.FaviconHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Type == nil {
				m.Type = &EventBlockFillBookmarkType{}
			}
			if err := m.Type.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetObjectId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetObjectId == nil {
				m.TargetObjectId = &EventBlockFillBookmarkTargetObjectId{}
			}
			if err := m.TargetObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockFillBookmarkType) 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 ErrIntOverflowEvents
			}
			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: Type: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Type: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= model.LinkPreviewType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataview) 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 ErrIntOverflowEvents
			}
			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: Dataview: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Dataview: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewSet) 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 ErrIntOverflowEvents
			}
			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: ViewSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewSet: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.View == nil {
				m.View = &model.BlockContentDataviewView{}
			}
			if err := m.View.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdate) 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 ErrIntOverflowEvents
			}
			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: ViewUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewUpdate: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filter = append(m.Filter, &EventBlockDataviewViewUpdateFilter{})
			if err := m.Filter[len(m.Filter)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relation = append(m.Relation, &EventBlockDataviewViewUpdateRelation{})
			if err := m.Relation[len(m.Relation)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sort = append(m.Sort, &EventBlockDataviewViewUpdateSort{})
			if err := m.Sort[len(m.Sort)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fields == nil {
				m.Fields = &EventBlockDataviewViewUpdateFields{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateFields) 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 ErrIntOverflowEvents
			}
			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: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= model.BlockContentDataviewViewType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoverRelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CoverRelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HideIcon", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HideIcon = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CardSize", wireType)
			}
			m.CardSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CardSize |= model.BlockContentDataviewViewSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoverFit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CoverFit = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupRelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupRelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupBackgroundColors", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.GroupBackgroundColors = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageLimit", wireType)
			}
			m.PageLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PageLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultTemplateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultTemplateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultObjectTypeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultObjectTypeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndRelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndRelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateFilter) 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 ErrIntOverflowEvents
			}
			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: Filter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Filter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateFilterAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateFilterOperationOfAdd{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateFilterRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateFilterOperationOfRemove{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateFilterUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateFilterOperationOfUpdate{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Move", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateFilterMove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateFilterOperationOfMove{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateFilterAdd) 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 ErrIntOverflowEvents
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &model.BlockContentDataviewFilter{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateFilterUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &model.BlockContentDataviewFilter{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateRelation) 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 ErrIntOverflowEvents
			}
			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: Relation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateRelationAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateRelationOperationOfAdd{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateRelationRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateRelationOperationOfRemove{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateRelationUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateRelationOperationOfUpdate{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Move", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateRelationMove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateRelationOperationOfMove{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateRelationAdd) 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 ErrIntOverflowEvents
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &model.BlockContentDataviewRelation{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateRelationUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &model.BlockContentDataviewRelation{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateSort) 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 ErrIntOverflowEvents
			}
			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: Sort: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sort: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateSortAdd{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateSortOperationOfAdd{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateSortRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateSortOperationOfRemove{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateSortUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateSortOperationOfUpdate{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Move", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventBlockDataviewViewUpdateSortMove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Operation = &EventBlockDataviewViewUpdateSortOperationOfMove{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateSortAdd) 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 ErrIntOverflowEvents
			}
			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: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &model.BlockContentDataviewSort{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewViewUpdateSortUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &model.BlockContentDataviewSort{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewOldRelationSet) 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 ErrIntOverflowEvents
			}
			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: OldRelationSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OldRelationSet: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewRelationSet) 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 ErrIntOverflowEvents
			}
			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: RelationSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationSet: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 RelationLinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationLinks = append(m.RelationLinks, &model.RelationLink{})
			if err := m.RelationLinks[len(m.RelationLinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewGroupOrderUpdate) 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 ErrIntOverflowEvents
			}
			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: GroupOrderUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupOrderUpdate: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 GroupOrder", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GroupOrder == nil {
				m.GroupOrder = &model.BlockContentDataviewGroupOrder{}
			}
			if err := m.GroupOrder.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewObjectOrderUpdate) 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 ErrIntOverflowEvents
			}
			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: ObjectOrderUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectOrderUpdate: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SliceChanges", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SliceChanges = append(m.SliceChanges, &EventBlockDataviewSliceChange{})
			if err := m.SliceChanges[len(m.SliceChanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewSliceChange) 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 ErrIntOverflowEvents
			}
			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: SliceChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SliceChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= EventBlockDataviewSliceOperation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventBlockDataviewIsCollectionSet) 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 ErrIntOverflowEvents
			}
			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: IsCollectionSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IsCollectionSet: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventUser) 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 ErrIntOverflowEvents
			}
			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: User: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: User: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventUserBlock) 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 ErrIntOverflowEvents
			}
			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: Block: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventUserBlockJoin) 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 ErrIntOverflowEvents
			}
			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: Join: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Join: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Account == nil {
				m.Account = &EventAccount{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventUserBlockLeft) 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 ErrIntOverflowEvents
			}
			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: Left: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Left: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Account == nil {
				m.Account = &EventAccount{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventUserBlockTextRange) 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 ErrIntOverflowEvents
			}
			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: TextRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TextRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Account == nil {
				m.Account = &EventAccount{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Range == nil {
				m.Range = &model.Range{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventPing) 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 ErrIntOverflowEvents
			}
			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: Ping: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ping: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventProcess) 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 ErrIntOverflowEvents
			}
			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: Process: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Process: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventProcessNew) 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 ErrIntOverflowEvents
			}
			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: New: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: New: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Process == nil {
				m.Process = &ModelProcess{}
			}
			if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventProcessUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Process == nil {
				m.Process = &ModelProcess{}
			}
			if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventProcessDone) 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 ErrIntOverflowEvents
			}
			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: Done: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Done: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Process", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Process == nil {
				m.Process = &ModelProcess{}
			}
			if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatus) 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 ErrIntOverflowEvents
			}
			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: Status: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatusThread) 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 ErrIntOverflowEvents
			}
			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: Thread: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Thread: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Summary", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Summary == nil {
				m.Summary = &EventStatusThreadSummary{}
			}
			if err := m.Summary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cafe", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cafe == nil {
				m.Cafe = &EventStatusThreadCafe{}
			}
			if err := m.Cafe.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Accounts = append(m.Accounts, &EventStatusThreadAccount{})
			if err := m.Accounts[len(m.Accounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatusThreadSummary) 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 ErrIntOverflowEvents
			}
			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: Summary: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Summary: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= EventStatusThreadSyncStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatusThreadCafe) 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 ErrIntOverflowEvents
			}
			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: Cafe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cafe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= EventStatusThreadSyncStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPulled", wireType)
			}
			m.LastPulled = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastPulled |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPushSucceed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LastPushSucceed = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Files == nil {
				m.Files = &EventStatusThreadCafePinStatus{}
			}
			if err := m.Files.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatusThreadCafePinStatus) 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 ErrIntOverflowEvents
			}
			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: PinStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PinStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pinning", wireType)
			}
			m.Pinning = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pinning |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pinned", wireType)
			}
			m.Pinned = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pinned |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
			}
			m.Failed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Failed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updated", wireType)
			}
			m.Updated = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Updated |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatusThreadAccount) 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 ErrIntOverflowEvents
			}
			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: Account: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Account: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			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 Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Online", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Online = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPulled", wireType)
			}
			m.LastPulled = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastPulled |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastEdited", wireType)
			}
			m.LastEdited = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastEdited |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Devices = append(m.Devices, &EventStatusThreadDevice{})
			if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventStatusThreadDevice) 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 ErrIntOverflowEvents
			}
			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: Device: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Device: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Online", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Online = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPulled", wireType)
			}
			m.LastPulled = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastPulled |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastEdited", wireType)
			}
			m.LastEdited = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastEdited |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventFile) 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 ErrIntOverflowEvents
			}
			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: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventFileLocalUsage) 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 ErrIntOverflowEvents
			}
			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: LocalUsage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LocalUsage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalBytesUsage", wireType)
			}
			m.LocalBytesUsage = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LocalBytesUsage |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventFileLimitUpdated) 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 ErrIntOverflowEvents
			}
			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: LimitUpdated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LimitUpdated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesLimit", wireType)
			}
			m.BytesLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMembership) 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 ErrIntOverflowEvents
			}
			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: Membership: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Membership: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMembershipUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &model.Membership{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventNotification) 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 ErrIntOverflowEvents
			}
			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: Notification: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Notification: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventNotificationSend) 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 ErrIntOverflowEvents
			}
			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: Send: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Send: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Notification", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Notification == nil {
				m.Notification = &model.Notification{}
			}
			if err := m.Notification.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventNotificationUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Notification", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Notification == nil {
				m.Notification = &model.Notification{}
			}
			if err := m.Notification.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventPayload) 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 ErrIntOverflowEvents
			}
			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: Payload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Payload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSpace) 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 ErrIntOverflowEvents
			}
			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: Space: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Space: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSpaceSyncStatus) 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 ErrIntOverflowEvents
			}
			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: SyncStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSpaceSyncStatusUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= EventSpaceStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			m.Network = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Network |= EventSpaceNetwork(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			m.Error = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Error |= EventSpaceSyncError(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncingObjectsCounter", wireType)
			}
			m.SyncingObjectsCounter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SyncingObjectsCounter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotSyncedFilesCounter", wireType)
			}
			m.NotSyncedFilesCounter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NotSyncedFilesCounter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventP2PStatus) 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 ErrIntOverflowEvents
			}
			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: P2PStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: P2PStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventP2PStatusUpdate) 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 ErrIntOverflowEvents
			}
			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: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= EventP2PStatusStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevicesCounter", wireType)
			}
			m.DevicesCounter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DevicesCounter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventImport) 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 ErrIntOverflowEvents
			}
			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: Import: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Import: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventImportFinish) 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 ErrIntOverflowEvents
			}
			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: Finish: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Finish: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootCollectionID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootCollectionID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectsCount", wireType)
			}
			m.ObjectsCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObjectsCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImportType", wireType)
			}
			m.ImportType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ImportType |= model.ImportType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResponseEvent) 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 ErrIntOverflowEvents
			}
			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: ResponseEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResponseEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Messages = append(m.Messages, &EventMessage{})
			if err := m.Messages[len(m.Messages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Model) 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 ErrIntOverflowEvents
			}
			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: Model: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Model: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcess) 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 ErrIntOverflowEvents
			}
			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: Process: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Process: 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 ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= ModelProcessState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Progress == nil {
				m.Progress = &ModelProcessProgress{}
			}
			if err := m.Progress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropFiles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModelProcessDropFiles{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ModelProcessMessageOfDropFiles{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Import", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModelProcessImport{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ModelProcessMessageOfImport{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModelProcessExport{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ModelProcessMessageOfExport{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaveFile", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModelProcessSaveFile{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ModelProcessMessageOfSaveFile{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Migration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModelProcessMigration{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ModelProcessMessageOfMigration{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreloadFile", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvents
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModelProcessPreloadFile{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Message = &ModelProcessMessageOfPreloadFile{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcessDropFiles) 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 ErrIntOverflowEvents
			}
			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: DropFiles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DropFiles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcessImport) 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 ErrIntOverflowEvents
			}
			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: Import: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Import: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcessExport) 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 ErrIntOverflowEvents
			}
			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: Export: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Export: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcessSaveFile) 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 ErrIntOverflowEvents
			}
			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: SaveFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SaveFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcessMigration) 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 ErrIntOverflowEvents
			}
			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: Migration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Migration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModelProcessPreloadFile) 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 ErrIntOverflowEvents
			}
			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: PreloadFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PreloadFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEvents(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, ErrIntOverflowEvents
			}
			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, ErrIntOverflowEvents
				}
				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, ErrIntOverflowEvents
				}
				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, ErrInvalidLengthEvents
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupEvents
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthEvents
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)
