// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/lib/pb/model/protos/models.proto

package model

import (
	fmt "fmt"
	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 SmartBlockType int32

const (
	SmartBlockType_AccountOld           SmartBlockType = 0
	SmartBlockType_Page                 SmartBlockType = 16
	SmartBlockType_ProfilePage          SmartBlockType = 17
	SmartBlockType_Home                 SmartBlockType = 32
	SmartBlockType_Archive              SmartBlockType = 48
	SmartBlockType_Widget               SmartBlockType = 112
	SmartBlockType_File                 SmartBlockType = 256
	SmartBlockType_Template             SmartBlockType = 288
	SmartBlockType_BundledTemplate      SmartBlockType = 289
	SmartBlockType_BundledRelation      SmartBlockType = 512
	SmartBlockType_SubObject            SmartBlockType = 513
	SmartBlockType_BundledObjectType    SmartBlockType = 514
	SmartBlockType_AnytypeProfile       SmartBlockType = 515
	SmartBlockType_Date                 SmartBlockType = 516
	SmartBlockType_Workspace            SmartBlockType = 518
	SmartBlockType_STRelation           SmartBlockType = 521
	SmartBlockType_STType               SmartBlockType = 528
	SmartBlockType_STRelationOption     SmartBlockType = 529
	SmartBlockType_SpaceView            SmartBlockType = 530
	SmartBlockType_Identity             SmartBlockType = 532
	SmartBlockType_Participant          SmartBlockType = 534
	SmartBlockType_MissingObject        SmartBlockType = 519
	SmartBlockType_FileObject           SmartBlockType = 533
	SmartBlockType_NotificationObject   SmartBlockType = 535
	SmartBlockType_DevicesObject        SmartBlockType = 536
	SmartBlockType_ChatObjectDeprecated SmartBlockType = 537
	SmartBlockType_ChatDerivedObject    SmartBlockType = 544
	SmartBlockType_AccountObject        SmartBlockType = 545
)

var SmartBlockType_name = map[int32]string{
	0:   "AccountOld",
	16:  "Page",
	17:  "ProfilePage",
	32:  "Home",
	48:  "Archive",
	112: "Widget",
	256: "File",
	288: "Template",
	289: "BundledTemplate",
	512: "BundledRelation",
	513: "SubObject",
	514: "BundledObjectType",
	515: "AnytypeProfile",
	516: "Date",
	518: "Workspace",
	521: "STRelation",
	528: "STType",
	529: "STRelationOption",
	530: "SpaceView",
	532: "Identity",
	534: "Participant",
	519: "MissingObject",
	533: "FileObject",
	535: "NotificationObject",
	536: "DevicesObject",
	537: "ChatObjectDeprecated",
	544: "ChatDerivedObject",
	545: "AccountObject",
}

var SmartBlockType_value = map[string]int32{
	"AccountOld":           0,
	"Page":                 16,
	"ProfilePage":          17,
	"Home":                 32,
	"Archive":              48,
	"Widget":               112,
	"File":                 256,
	"Template":             288,
	"BundledTemplate":      289,
	"BundledRelation":      512,
	"SubObject":            513,
	"BundledObjectType":    514,
	"AnytypeProfile":       515,
	"Date":                 516,
	"Workspace":            518,
	"STRelation":           521,
	"STType":               528,
	"STRelationOption":     529,
	"SpaceView":            530,
	"Identity":             532,
	"Participant":          534,
	"MissingObject":        519,
	"FileObject":           533,
	"NotificationObject":   535,
	"DevicesObject":        536,
	"ChatObjectDeprecated": 537,
	"ChatDerivedObject":    544,
	"AccountObject":        545,
}

func (x SmartBlockType) String() string {
	return proto.EnumName(SmartBlockType_name, int32(x))
}

func (SmartBlockType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{0}
}

// RelationFormat describes how the underlying data is stored in the google.protobuf.Value and how it should be validated/sanitized
type RelationFormat int32

const (
	RelationFormat_longtext  RelationFormat = 0
	RelationFormat_shorttext RelationFormat = 1
	RelationFormat_number    RelationFormat = 2
	RelationFormat_status    RelationFormat = 3
	RelationFormat_tag       RelationFormat = 11
	RelationFormat_date      RelationFormat = 4
	RelationFormat_file      RelationFormat = 5
	RelationFormat_checkbox  RelationFormat = 6
	RelationFormat_url       RelationFormat = 7
	RelationFormat_email     RelationFormat = 8
	RelationFormat_phone     RelationFormat = 9
	RelationFormat_emoji     RelationFormat = 10
	RelationFormat_object    RelationFormat = 100
	RelationFormat_relations RelationFormat = 101
)

var RelationFormat_name = map[int32]string{
	0:   "longtext",
	1:   "shorttext",
	2:   "number",
	3:   "status",
	11:  "tag",
	4:   "date",
	5:   "file",
	6:   "checkbox",
	7:   "url",
	8:   "email",
	9:   "phone",
	10:  "emoji",
	100: "object",
	101: "relations",
}

var RelationFormat_value = map[string]int32{
	"longtext":  0,
	"shorttext": 1,
	"number":    2,
	"status":    3,
	"tag":       11,
	"date":      4,
	"file":      5,
	"checkbox":  6,
	"url":       7,
	"email":     8,
	"phone":     9,
	"emoji":     10,
	"object":    100,
	"relations": 101,
}

func (x RelationFormat) String() string {
	return proto.EnumName(RelationFormat_name, int32(x))
}

func (RelationFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{1}
}

type ObjectOrigin int32

const (
	ObjectOrigin_none             ObjectOrigin = 0
	ObjectOrigin_clipboard        ObjectOrigin = 1
	ObjectOrigin_dragAndDrop      ObjectOrigin = 2
	ObjectOrigin_import           ObjectOrigin = 3
	ObjectOrigin_webclipper       ObjectOrigin = 4
	ObjectOrigin_sharingExtension ObjectOrigin = 5
	ObjectOrigin_usecase          ObjectOrigin = 6
	ObjectOrigin_builtin          ObjectOrigin = 7
	ObjectOrigin_bookmark         ObjectOrigin = 8
	ObjectOrigin_api              ObjectOrigin = 9
)

var ObjectOrigin_name = map[int32]string{
	0: "none",
	1: "clipboard",
	2: "dragAndDrop",
	3: "import",
	4: "webclipper",
	5: "sharingExtension",
	6: "usecase",
	7: "builtin",
	8: "bookmark",
	9: "api",
}

var ObjectOrigin_value = map[string]int32{
	"none":             0,
	"clipboard":        1,
	"dragAndDrop":      2,
	"import":           3,
	"webclipper":       4,
	"sharingExtension": 5,
	"usecase":          6,
	"builtin":          7,
	"bookmark":         8,
	"api":              9,
}

func (x ObjectOrigin) String() string {
	return proto.EnumName(ObjectOrigin_name, int32(x))
}

func (ObjectOrigin) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2}
}

type SpaceStatus int32

const (
	// Unknown means the space is not loaded yet
	SpaceStatus_Unknown SpaceStatus = 0
	// Loading - the space in progress of loading
	SpaceStatus_Loading SpaceStatus = 1
	// Ok - the space loaded and available
	SpaceStatus_Ok SpaceStatus = 2
	// Missing - the space is missing
	SpaceStatus_Missing SpaceStatus = 3
	// Error - the space loading ended with an error
	SpaceStatus_Error SpaceStatus = 4
	// RemoteWaitingDeletion - network status is "waiting deletion"
	SpaceStatus_RemoteWaitingDeletion SpaceStatus = 5
	// RemoteDeleted - the space is deleted in the current network
	SpaceStatus_RemoteDeleted SpaceStatus = 6
	// SpaceDeleted - the space should be deleted in the network
	SpaceStatus_SpaceDeleted SpaceStatus = 7
	// SpaceActive - the space is active in the network
	SpaceStatus_SpaceActive SpaceStatus = 8
	// SpaceJoining - the account is joining the space
	SpaceStatus_SpaceJoining SpaceStatus = 9
	// SpaceRemoving - the account is removing from space or the space is removed from network
	SpaceStatus_SpaceRemoving SpaceStatus = 10
)

var SpaceStatus_name = map[int32]string{
	0:  "Unknown",
	1:  "Loading",
	2:  "Ok",
	3:  "Missing",
	4:  "Error",
	5:  "RemoteWaitingDeletion",
	6:  "RemoteDeleted",
	7:  "SpaceDeleted",
	8:  "SpaceActive",
	9:  "SpaceJoining",
	10: "SpaceRemoving",
}

var SpaceStatus_value = map[string]int32{
	"Unknown":               0,
	"Loading":               1,
	"Ok":                    2,
	"Missing":               3,
	"Error":                 4,
	"RemoteWaitingDeletion": 5,
	"RemoteDeleted":         6,
	"SpaceDeleted":          7,
	"SpaceActive":           8,
	"SpaceJoining":          9,
	"SpaceRemoving":         10,
}

func (x SpaceStatus) String() string {
	return proto.EnumName(SpaceStatus_name, int32(x))
}

func (SpaceStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{3}
}

type ParticipantPermissions int32

const (
	ParticipantPermissions_Reader        ParticipantPermissions = 0
	ParticipantPermissions_Writer        ParticipantPermissions = 1
	ParticipantPermissions_Owner         ParticipantPermissions = 2
	ParticipantPermissions_NoPermissions ParticipantPermissions = 3
)

var ParticipantPermissions_name = map[int32]string{
	0: "Reader",
	1: "Writer",
	2: "Owner",
	3: "NoPermissions",
}

var ParticipantPermissions_value = map[string]int32{
	"Reader":        0,
	"Writer":        1,
	"Owner":         2,
	"NoPermissions": 3,
}

func (x ParticipantPermissions) String() string {
	return proto.EnumName(ParticipantPermissions_name, int32(x))
}

func (ParticipantPermissions) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{4}
}

type InviteType int32

const (
	InviteType_Member         InviteType = 0
	InviteType_Guest          InviteType = 1
	InviteType_WithoutApprove InviteType = 2
)

var InviteType_name = map[int32]string{
	0: "Member",
	1: "Guest",
	2: "WithoutApprove",
}

var InviteType_value = map[string]int32{
	"Member":         0,
	"Guest":          1,
	"WithoutApprove": 2,
}

func (x InviteType) String() string {
	return proto.EnumName(InviteType_name, int32(x))
}

func (InviteType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{5}
}

type ParticipantStatus int32

const (
	ParticipantStatus_Joining  ParticipantStatus = 0
	ParticipantStatus_Active   ParticipantStatus = 1
	ParticipantStatus_Removed  ParticipantStatus = 2
	ParticipantStatus_Declined ParticipantStatus = 3
	ParticipantStatus_Removing ParticipantStatus = 4
	ParticipantStatus_Canceled ParticipantStatus = 5
)

var ParticipantStatus_name = map[int32]string{
	0: "Joining",
	1: "Active",
	2: "Removed",
	3: "Declined",
	4: "Removing",
	5: "Canceled",
}

var ParticipantStatus_value = map[string]int32{
	"Joining":  0,
	"Active":   1,
	"Removed":  2,
	"Declined": 3,
	"Removing": 4,
	"Canceled": 5,
}

func (x ParticipantStatus) String() string {
	return proto.EnumName(ParticipantStatus_name, int32(x))
}

func (ParticipantStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{6}
}

type SpaceAccessType int32

const (
	SpaceAccessType_Private  SpaceAccessType = 0
	SpaceAccessType_Personal SpaceAccessType = 1
	SpaceAccessType_Shared   SpaceAccessType = 2
)

var SpaceAccessType_name = map[int32]string{
	0: "Private",
	1: "Personal",
	2: "Shared",
}

var SpaceAccessType_value = map[string]int32{
	"Private":  0,
	"Personal": 1,
	"Shared":   2,
}

func (x SpaceAccessType) String() string {
	return proto.EnumName(SpaceAccessType_name, int32(x))
}

func (SpaceAccessType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{7}
}

type SpaceUxType int32

const (
	SpaceUxType_None   SpaceUxType = 0
	SpaceUxType_Data   SpaceUxType = 1
	SpaceUxType_Stream SpaceUxType = 2
	SpaceUxType_Chat   SpaceUxType = 3
)

var SpaceUxType_name = map[int32]string{
	0: "None",
	1: "Data",
	2: "Stream",
	3: "Chat",
}

var SpaceUxType_value = map[string]int32{
	"None":   0,
	"Data":   1,
	"Stream": 2,
	"Chat":   3,
}

func (x SpaceUxType) String() string {
	return proto.EnumName(SpaceUxType_name, int32(x))
}

func (SpaceUxType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{8}
}

type ImageKind int32

const (
	ImageKind_Basic              ImageKind = 0
	ImageKind_Cover              ImageKind = 1
	ImageKind_Icon               ImageKind = 2
	ImageKind_AutomaticallyAdded ImageKind = 3
)

var ImageKind_name = map[int32]string{
	0: "Basic",
	1: "Cover",
	2: "Icon",
	3: "AutomaticallyAdded",
}

var ImageKind_value = map[string]int32{
	"Basic":              0,
	"Cover":              1,
	"Icon":               2,
	"AutomaticallyAdded": 3,
}

func (x ImageKind) String() string {
	return proto.EnumName(ImageKind_name, int32(x))
}

func (ImageKind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{9}
}

type FileIndexingStatus int32

const (
	FileIndexingStatus_NotIndexed FileIndexingStatus = 0
	FileIndexingStatus_Indexed    FileIndexingStatus = 1
	FileIndexingStatus_NotFound   FileIndexingStatus = 2
)

var FileIndexingStatus_name = map[int32]string{
	0: "NotIndexed",
	1: "Indexed",
	2: "NotFound",
}

var FileIndexingStatus_value = map[string]int32{
	"NotIndexed": 0,
	"Indexed":    1,
	"NotFound":   2,
}

func (x FileIndexingStatus) String() string {
	return proto.EnumName(FileIndexingStatus_name, int32(x))
}

func (FileIndexingStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{10}
}

type SpaceShareableStatus int32

const (
	SpaceShareableStatus_StatusUnknown      SpaceShareableStatus = 0
	SpaceShareableStatus_StatusShareable    SpaceShareableStatus = 1
	SpaceShareableStatus_StatusNotShareable SpaceShareableStatus = 2
)

var SpaceShareableStatus_name = map[int32]string{
	0: "StatusUnknown",
	1: "StatusShareable",
	2: "StatusNotShareable",
}

var SpaceShareableStatus_value = map[string]int32{
	"StatusUnknown":      0,
	"StatusShareable":    1,
	"StatusNotShareable": 2,
}

func (x SpaceShareableStatus) String() string {
	return proto.EnumName(SpaceShareableStatus_name, int32(x))
}

func (SpaceShareableStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{11}
}

type NameserviceNameType int32

const (
	// .any suffix
	NameserviceNameType_AnyName NameserviceNameType = 0
)

var NameserviceNameType_name = map[int32]string{
	0: "AnyName",
}

var NameserviceNameType_value = map[string]int32{
	"AnyName": 0,
}

func (x NameserviceNameType) String() string {
	return proto.EnumName(NameserviceNameType_name, int32(x))
}

func (NameserviceNameType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{12}
}

type DeviceNetworkType int32

const (
	DeviceNetworkType_WIFI          DeviceNetworkType = 0
	DeviceNetworkType_CELLULAR      DeviceNetworkType = 1
	DeviceNetworkType_NOT_CONNECTED DeviceNetworkType = 2
)

var DeviceNetworkType_name = map[int32]string{
	0: "WIFI",
	1: "CELLULAR",
	2: "NOT_CONNECTED",
}

var DeviceNetworkType_value = map[string]int32{
	"WIFI":          0,
	"CELLULAR":      1,
	"NOT_CONNECTED": 2,
}

func (x DeviceNetworkType) String() string {
	return proto.EnumName(DeviceNetworkType_name, int32(x))
}

func (DeviceNetworkType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{13}
}

type SyncStatus int32

const (
	SyncStatus_SyncStatusSynced  SyncStatus = 0
	SyncStatus_SyncStatusSyncing SyncStatus = 1
	SyncStatus_SyncStatusError   SyncStatus = 2
	SyncStatus_SyncStatusQueued  SyncStatus = 3
)

var SyncStatus_name = map[int32]string{
	0: "SyncStatusSynced",
	1: "SyncStatusSyncing",
	2: "SyncStatusError",
	3: "SyncStatusQueued",
}

var SyncStatus_value = map[string]int32{
	"SyncStatusSynced":  0,
	"SyncStatusSyncing": 1,
	"SyncStatusError":   2,
	"SyncStatusQueued":  3,
}

func (x SyncStatus) String() string {
	return proto.EnumName(SyncStatus_name, int32(x))
}

func (SyncStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{14}
}

type SyncError int32

const (
	SyncError_SyncErrorNull                SyncError = 0
	SyncError_SyncErrorIncompatibleVersion SyncError = 2
	SyncError_SyncErrorNetworkError        SyncError = 3
	SyncError_SyncErrorOversized           SyncError = 4
)

var SyncError_name = map[int32]string{
	0: "SyncErrorNull",
	2: "SyncErrorIncompatibleVersion",
	3: "SyncErrorNetworkError",
	4: "SyncErrorOversized",
}

var SyncError_value = map[string]int32{
	"SyncErrorNull":                0,
	"SyncErrorIncompatibleVersion": 2,
	"SyncErrorNetworkError":        3,
	"SyncErrorOversized":           4,
}

func (x SyncError) String() string {
	return proto.EnumName(SyncError_name, int32(x))
}

func (SyncError) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{15}
}

type BlockPosition int32

const (
	Block_None BlockPosition = 0
	// above target block
	Block_Top BlockPosition = 1
	// under target block
	Block_Bottom BlockPosition = 2
	// to left of target block
	Block_Left BlockPosition = 3
	// to right of target block
	Block_Right BlockPosition = 4
	// inside target block, as last block
	Block_Inner BlockPosition = 5
	// replace target block
	Block_Replace BlockPosition = 6
	// inside target block, as first block
	Block_InnerFirst BlockPosition = 7
)

var BlockPosition_name = map[int32]string{
	0: "None",
	1: "Top",
	2: "Bottom",
	3: "Left",
	4: "Right",
	5: "Inner",
	6: "Replace",
	7: "InnerFirst",
}

var BlockPosition_value = map[string]int32{
	"None":       0,
	"Top":        1,
	"Bottom":     2,
	"Left":       3,
	"Right":      4,
	"Inner":      5,
	"Replace":    6,
	"InnerFirst": 7,
}

func (x BlockPosition) String() string {
	return proto.EnumName(BlockPosition_name, int32(x))
}

func (BlockPosition) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 0}
}

type BlockAlign int32

const (
	Block_AlignLeft    BlockAlign = 0
	Block_AlignCenter  BlockAlign = 1
	Block_AlignRight   BlockAlign = 2
	Block_AlignJustify BlockAlign = 3
)

var BlockAlign_name = map[int32]string{
	0: "AlignLeft",
	1: "AlignCenter",
	2: "AlignRight",
	3: "AlignJustify",
}

var BlockAlign_value = map[string]int32{
	"AlignLeft":    0,
	"AlignCenter":  1,
	"AlignRight":   2,
	"AlignJustify": 3,
}

func (x BlockAlign) String() string {
	return proto.EnumName(BlockAlign_name, int32(x))
}

func (BlockAlign) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1}
}

type BlockVerticalAlign int32

const (
	Block_VerticalAlignTop    BlockVerticalAlign = 0
	Block_VerticalAlignMiddle BlockVerticalAlign = 1
	Block_VerticalAlignBottom BlockVerticalAlign = 2
)

var BlockVerticalAlign_name = map[int32]string{
	0: "VerticalAlignTop",
	1: "VerticalAlignMiddle",
	2: "VerticalAlignBottom",
}

var BlockVerticalAlign_value = map[string]int32{
	"VerticalAlignTop":    0,
	"VerticalAlignMiddle": 1,
	"VerticalAlignBottom": 2,
}

func (x BlockVerticalAlign) String() string {
	return proto.EnumName(BlockVerticalAlign_name, int32(x))
}

func (BlockVerticalAlign) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 2}
}

type BlockContentLayoutStyle int32

const (
	BlockContentLayout_Row          BlockContentLayoutStyle = 0
	BlockContentLayout_Column       BlockContentLayoutStyle = 1
	BlockContentLayout_Div          BlockContentLayoutStyle = 2
	BlockContentLayout_Header       BlockContentLayoutStyle = 3
	BlockContentLayout_TableRows    BlockContentLayoutStyle = 4
	BlockContentLayout_TableColumns BlockContentLayoutStyle = 5
)

var BlockContentLayoutStyle_name = map[int32]string{
	0: "Row",
	1: "Column",
	2: "Div",
	3: "Header",
	4: "TableRows",
	5: "TableColumns",
}

var BlockContentLayoutStyle_value = map[string]int32{
	"Row":          0,
	"Column":       1,
	"Div":          2,
	"Header":       3,
	"TableRows":    4,
	"TableColumns": 5,
}

func (x BlockContentLayoutStyle) String() string {
	return proto.EnumName(BlockContentLayoutStyle_name, int32(x))
}

func (BlockContentLayoutStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 0, 0}
}

type BlockContentLinkIconSize int32

const (
	BlockContentLink_SizeNone   BlockContentLinkIconSize = 0
	BlockContentLink_SizeSmall  BlockContentLinkIconSize = 1
	BlockContentLink_SizeMedium BlockContentLinkIconSize = 2
)

var BlockContentLinkIconSize_name = map[int32]string{
	0: "SizeNone",
	1: "SizeSmall",
	2: "SizeMedium",
}

var BlockContentLinkIconSize_value = map[string]int32{
	"SizeNone":   0,
	"SizeSmall":  1,
	"SizeMedium": 2,
}

func (x BlockContentLinkIconSize) String() string {
	return proto.EnumName(BlockContentLinkIconSize_name, int32(x))
}

func (BlockContentLinkIconSize) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 1, 0}
}

type BlockContentLinkStyle int32

const (
	BlockContentLink_Page      BlockContentLinkStyle = 0
	BlockContentLink_Dataview  BlockContentLinkStyle = 1
	BlockContentLink_Dashboard BlockContentLinkStyle = 2
	BlockContentLink_Archive   BlockContentLinkStyle = 3
)

var BlockContentLinkStyle_name = map[int32]string{
	0: "Page",
	1: "Dataview",
	2: "Dashboard",
	3: "Archive",
}

var BlockContentLinkStyle_value = map[string]int32{
	"Page":      0,
	"Dataview":  1,
	"Dashboard": 2,
	"Archive":   3,
}

func (x BlockContentLinkStyle) String() string {
	return proto.EnumName(BlockContentLinkStyle_name, int32(x))
}

func (BlockContentLinkStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 1, 1}
}

type BlockContentLinkDescription int32

const (
	BlockContentLink_None    BlockContentLinkDescription = 0
	BlockContentLink_Added   BlockContentLinkDescription = 1
	BlockContentLink_Content BlockContentLinkDescription = 2
)

var BlockContentLinkDescription_name = map[int32]string{
	0: "None",
	1: "Added",
	2: "Content",
}

var BlockContentLinkDescription_value = map[string]int32{
	"None":    0,
	"Added":   1,
	"Content": 2,
}

func (x BlockContentLinkDescription) String() string {
	return proto.EnumName(BlockContentLinkDescription_name, int32(x))
}

func (BlockContentLinkDescription) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 1, 2}
}

type BlockContentLinkCardStyle int32

const (
	BlockContentLink_Text   BlockContentLinkCardStyle = 0
	BlockContentLink_Card   BlockContentLinkCardStyle = 1
	BlockContentLink_Inline BlockContentLinkCardStyle = 2
)

var BlockContentLinkCardStyle_name = map[int32]string{
	0: "Text",
	1: "Card",
	2: "Inline",
}

var BlockContentLinkCardStyle_value = map[string]int32{
	"Text":   0,
	"Card":   1,
	"Inline": 2,
}

func (x BlockContentLinkCardStyle) String() string {
	return proto.EnumName(BlockContentLinkCardStyle_name, int32(x))
}

func (BlockContentLinkCardStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 1, 3}
}

type BlockContentDivStyle int32

const (
	BlockContentDiv_Line BlockContentDivStyle = 0
	BlockContentDiv_Dots BlockContentDivStyle = 1
)

var BlockContentDivStyle_name = map[int32]string{
	0: "Line",
	1: "Dots",
}

var BlockContentDivStyle_value = map[string]int32{
	"Line": 0,
	"Dots": 1,
}

func (x BlockContentDivStyle) String() string {
	return proto.EnumName(BlockContentDivStyle_name, int32(x))
}

func (BlockContentDivStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 2, 0}
}

type BlockContentBookmarkState int32

const (
	BlockContentBookmark_Empty    BlockContentBookmarkState = 0
	BlockContentBookmark_Fetching BlockContentBookmarkState = 1
	BlockContentBookmark_Done     BlockContentBookmarkState = 2
	BlockContentBookmark_Error    BlockContentBookmarkState = 3
)

var BlockContentBookmarkState_name = map[int32]string{
	0: "Empty",
	1: "Fetching",
	2: "Done",
	3: "Error",
}

var BlockContentBookmarkState_value = map[string]int32{
	"Empty":    0,
	"Fetching": 1,
	"Done":     2,
	"Error":    3,
}

func (x BlockContentBookmarkState) String() string {
	return proto.EnumName(BlockContentBookmarkState_name, int32(x))
}

func (BlockContentBookmarkState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 3, 0}
}

type BlockContentTextStyle int32

const (
	BlockContentText_Paragraph   BlockContentTextStyle = 0
	BlockContentText_Header1     BlockContentTextStyle = 1
	BlockContentText_Header2     BlockContentTextStyle = 2
	BlockContentText_Header3     BlockContentTextStyle = 3
	BlockContentText_Header4     BlockContentTextStyle = 4
	BlockContentText_Quote       BlockContentTextStyle = 5
	BlockContentText_Code        BlockContentTextStyle = 6
	BlockContentText_Title       BlockContentTextStyle = 7
	BlockContentText_Checkbox    BlockContentTextStyle = 8
	BlockContentText_Marked      BlockContentTextStyle = 9
	BlockContentText_Numbered    BlockContentTextStyle = 10
	BlockContentText_Toggle      BlockContentTextStyle = 11
	BlockContentText_Description BlockContentTextStyle = 12
	BlockContentText_Callout     BlockContentTextStyle = 13
)

var BlockContentTextStyle_name = map[int32]string{
	0:  "Paragraph",
	1:  "Header1",
	2:  "Header2",
	3:  "Header3",
	4:  "Header4",
	5:  "Quote",
	6:  "Code",
	7:  "Title",
	8:  "Checkbox",
	9:  "Marked",
	10: "Numbered",
	11: "Toggle",
	12: "Description",
	13: "Callout",
}

var BlockContentTextStyle_value = map[string]int32{
	"Paragraph":   0,
	"Header1":     1,
	"Header2":     2,
	"Header3":     3,
	"Header4":     4,
	"Quote":       5,
	"Code":        6,
	"Title":       7,
	"Checkbox":    8,
	"Marked":      9,
	"Numbered":    10,
	"Toggle":      11,
	"Description": 12,
	"Callout":     13,
}

func (x BlockContentTextStyle) String() string {
	return proto.EnumName(BlockContentTextStyle_name, int32(x))
}

func (BlockContentTextStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 6, 0}
}

type BlockContentTextMarkType int32

const (
	BlockContentTextMark_Strikethrough   BlockContentTextMarkType = 0
	BlockContentTextMark_Keyboard        BlockContentTextMarkType = 1
	BlockContentTextMark_Italic          BlockContentTextMarkType = 2
	BlockContentTextMark_Bold            BlockContentTextMarkType = 3
	BlockContentTextMark_Underscored     BlockContentTextMarkType = 4
	BlockContentTextMark_Link            BlockContentTextMarkType = 5
	BlockContentTextMark_TextColor       BlockContentTextMarkType = 6
	BlockContentTextMark_BackgroundColor BlockContentTextMarkType = 7
	BlockContentTextMark_Mention         BlockContentTextMarkType = 8
	BlockContentTextMark_Emoji           BlockContentTextMarkType = 9
	BlockContentTextMark_Object          BlockContentTextMarkType = 10
)

var BlockContentTextMarkType_name = map[int32]string{
	0:  "Strikethrough",
	1:  "Keyboard",
	2:  "Italic",
	3:  "Bold",
	4:  "Underscored",
	5:  "Link",
	6:  "TextColor",
	7:  "BackgroundColor",
	8:  "Mention",
	9:  "Emoji",
	10: "Object",
}

var BlockContentTextMarkType_value = map[string]int32{
	"Strikethrough":   0,
	"Keyboard":        1,
	"Italic":          2,
	"Bold":            3,
	"Underscored":     4,
	"Link":            5,
	"TextColor":       6,
	"BackgroundColor": 7,
	"Mention":         8,
	"Emoji":           9,
	"Object":          10,
}

func (x BlockContentTextMarkType) String() string {
	return proto.EnumName(BlockContentTextMarkType_name, int32(x))
}

func (BlockContentTextMarkType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 6, 1, 0}
}

type BlockContentFileType int32

const (
	BlockContentFile_None  BlockContentFileType = 0
	BlockContentFile_File  BlockContentFileType = 1
	BlockContentFile_Image BlockContentFileType = 2
	BlockContentFile_Video BlockContentFileType = 3
	BlockContentFile_Audio BlockContentFileType = 4
	BlockContentFile_PDF   BlockContentFileType = 5
)

var BlockContentFileType_name = map[int32]string{
	0: "None",
	1: "File",
	2: "Image",
	3: "Video",
	4: "Audio",
	5: "PDF",
}

var BlockContentFileType_value = map[string]int32{
	"None":  0,
	"File":  1,
	"Image": 2,
	"Video": 3,
	"Audio": 4,
	"PDF":   5,
}

func (x BlockContentFileType) String() string {
	return proto.EnumName(BlockContentFileType_name, int32(x))
}

func (BlockContentFileType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 7, 0}
}

type BlockContentFileStyle int32

const (
	BlockContentFile_Auto  BlockContentFileStyle = 0
	BlockContentFile_Link  BlockContentFileStyle = 1
	BlockContentFile_Embed BlockContentFileStyle = 2
)

var BlockContentFileStyle_name = map[int32]string{
	0: "Auto",
	1: "Link",
	2: "Embed",
}

var BlockContentFileStyle_value = map[string]int32{
	"Auto":  0,
	"Link":  1,
	"Embed": 2,
}

func (x BlockContentFileStyle) String() string {
	return proto.EnumName(BlockContentFileStyle_name, int32(x))
}

func (BlockContentFileStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 7, 1}
}

type BlockContentFileState int32

const (
	BlockContentFile_Empty     BlockContentFileState = 0
	BlockContentFile_Uploading BlockContentFileState = 1
	BlockContentFile_Done      BlockContentFileState = 2
	BlockContentFile_Error     BlockContentFileState = 3
)

var BlockContentFileState_name = map[int32]string{
	0: "Empty",
	1: "Uploading",
	2: "Done",
	3: "Error",
}

var BlockContentFileState_value = map[string]int32{
	"Empty":     0,
	"Uploading": 1,
	"Done":      2,
	"Error":     3,
}

func (x BlockContentFileState) String() string {
	return proto.EnumName(BlockContentFileState_name, int32(x))
}

func (BlockContentFileState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 7, 2}
}

type BlockContentDataviewViewType int32

const (
	BlockContentDataviewView_Table    BlockContentDataviewViewType = 0
	BlockContentDataviewView_List     BlockContentDataviewViewType = 1
	BlockContentDataviewView_Gallery  BlockContentDataviewViewType = 2
	BlockContentDataviewView_Kanban   BlockContentDataviewViewType = 3
	BlockContentDataviewView_Calendar BlockContentDataviewViewType = 4
	BlockContentDataviewView_Graph    BlockContentDataviewViewType = 5
)

var BlockContentDataviewViewType_name = map[int32]string{
	0: "Table",
	1: "List",
	2: "Gallery",
	3: "Kanban",
	4: "Calendar",
	5: "Graph",
}

var BlockContentDataviewViewType_value = map[string]int32{
	"Table":    0,
	"List":     1,
	"Gallery":  2,
	"Kanban":   3,
	"Calendar": 4,
	"Graph":    5,
}

func (x BlockContentDataviewViewType) String() string {
	return proto.EnumName(BlockContentDataviewViewType_name, int32(x))
}

func (BlockContentDataviewViewType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 0, 0}
}

type BlockContentDataviewViewSize int32

const (
	BlockContentDataviewView_Small  BlockContentDataviewViewSize = 0
	BlockContentDataviewView_Medium BlockContentDataviewViewSize = 1
	BlockContentDataviewView_Large  BlockContentDataviewViewSize = 2
)

var BlockContentDataviewViewSize_name = map[int32]string{
	0: "Small",
	1: "Medium",
	2: "Large",
}

var BlockContentDataviewViewSize_value = map[string]int32{
	"Small":  0,
	"Medium": 1,
	"Large":  2,
}

func (x BlockContentDataviewViewSize) String() string {
	return proto.EnumName(BlockContentDataviewViewSize_name, int32(x))
}

func (BlockContentDataviewViewSize) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 0, 1}
}

type BlockContentDataviewRelationDateFormat int32

const (
	BlockContentDataviewRelation_MonthAbbrBeforeDay BlockContentDataviewRelationDateFormat = 0
	BlockContentDataviewRelation_MonthAbbrAfterDay  BlockContentDataviewRelationDateFormat = 1
	BlockContentDataviewRelation_Short              BlockContentDataviewRelationDateFormat = 2
	BlockContentDataviewRelation_ShortUS            BlockContentDataviewRelationDateFormat = 3
	BlockContentDataviewRelation_ISO                BlockContentDataviewRelationDateFormat = 4
)

var BlockContentDataviewRelationDateFormat_name = map[int32]string{
	0: "MonthAbbrBeforeDay",
	1: "MonthAbbrAfterDay",
	2: "Short",
	3: "ShortUS",
	4: "ISO",
}

var BlockContentDataviewRelationDateFormat_value = map[string]int32{
	"MonthAbbrBeforeDay": 0,
	"MonthAbbrAfterDay":  1,
	"Short":              2,
	"ShortUS":            3,
	"ISO":                4,
}

func (x BlockContentDataviewRelationDateFormat) String() string {
	return proto.EnumName(BlockContentDataviewRelationDateFormat_name, int32(x))
}

func (BlockContentDataviewRelationDateFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 1, 0}
}

type BlockContentDataviewRelationTimeFormat int32

const (
	BlockContentDataviewRelation_Format12 BlockContentDataviewRelationTimeFormat = 0
	BlockContentDataviewRelation_Format24 BlockContentDataviewRelationTimeFormat = 1
)

var BlockContentDataviewRelationTimeFormat_name = map[int32]string{
	0: "Format12",
	1: "Format24",
}

var BlockContentDataviewRelationTimeFormat_value = map[string]int32{
	"Format12": 0,
	"Format24": 1,
}

func (x BlockContentDataviewRelationTimeFormat) String() string {
	return proto.EnumName(BlockContentDataviewRelationTimeFormat_name, int32(x))
}

func (BlockContentDataviewRelationTimeFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 1, 1}
}

type BlockContentDataviewRelationFormulaType int32

const (
	BlockContentDataviewRelation_None            BlockContentDataviewRelationFormulaType = 0
	BlockContentDataviewRelation_Count           BlockContentDataviewRelationFormulaType = 1
	BlockContentDataviewRelation_CountValue      BlockContentDataviewRelationFormulaType = 2
	BlockContentDataviewRelation_CountDistinct   BlockContentDataviewRelationFormulaType = 3
	BlockContentDataviewRelation_CountEmpty      BlockContentDataviewRelationFormulaType = 4
	BlockContentDataviewRelation_CountNotEmpty   BlockContentDataviewRelationFormulaType = 5
	BlockContentDataviewRelation_PercentEmpty    BlockContentDataviewRelationFormulaType = 6
	BlockContentDataviewRelation_PercentNotEmpty BlockContentDataviewRelationFormulaType = 7
	BlockContentDataviewRelation_MathSum         BlockContentDataviewRelationFormulaType = 8
	BlockContentDataviewRelation_MathAverage     BlockContentDataviewRelationFormulaType = 9
	BlockContentDataviewRelation_MathMedian      BlockContentDataviewRelationFormulaType = 10
	BlockContentDataviewRelation_MathMin         BlockContentDataviewRelationFormulaType = 11
	BlockContentDataviewRelation_MathMax         BlockContentDataviewRelationFormulaType = 12
	BlockContentDataviewRelation_Range           BlockContentDataviewRelationFormulaType = 13
)

var BlockContentDataviewRelationFormulaType_name = map[int32]string{
	0:  "None",
	1:  "Count",
	2:  "CountValue",
	3:  "CountDistinct",
	4:  "CountEmpty",
	5:  "CountNotEmpty",
	6:  "PercentEmpty",
	7:  "PercentNotEmpty",
	8:  "MathSum",
	9:  "MathAverage",
	10: "MathMedian",
	11: "MathMin",
	12: "MathMax",
	13: "Range",
}

var BlockContentDataviewRelationFormulaType_value = map[string]int32{
	"None":            0,
	"Count":           1,
	"CountValue":      2,
	"CountDistinct":   3,
	"CountEmpty":      4,
	"CountNotEmpty":   5,
	"PercentEmpty":    6,
	"PercentNotEmpty": 7,
	"MathSum":         8,
	"MathAverage":     9,
	"MathMedian":      10,
	"MathMin":         11,
	"MathMax":         12,
	"Range":           13,
}

func (x BlockContentDataviewRelationFormulaType) String() string {
	return proto.EnumName(BlockContentDataviewRelationFormulaType_name, int32(x))
}

func (BlockContentDataviewRelationFormulaType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 1, 2}
}

type BlockContentDataviewSortType int32

const (
	BlockContentDataviewSort_Asc    BlockContentDataviewSortType = 0
	BlockContentDataviewSort_Desc   BlockContentDataviewSortType = 1
	BlockContentDataviewSort_Custom BlockContentDataviewSortType = 2
)

var BlockContentDataviewSortType_name = map[int32]string{
	0: "Asc",
	1: "Desc",
	2: "Custom",
}

var BlockContentDataviewSortType_value = map[string]int32{
	"Asc":    0,
	"Desc":   1,
	"Custom": 2,
}

func (x BlockContentDataviewSortType) String() string {
	return proto.EnumName(BlockContentDataviewSortType_name, int32(x))
}

func (BlockContentDataviewSortType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 2, 0}
}

type BlockContentDataviewSortEmptyType int32

const (
	BlockContentDataviewSort_NotSpecified BlockContentDataviewSortEmptyType = 0
	BlockContentDataviewSort_Start        BlockContentDataviewSortEmptyType = 1
	BlockContentDataviewSort_End          BlockContentDataviewSortEmptyType = 2
)

var BlockContentDataviewSortEmptyType_name = map[int32]string{
	0: "NotSpecified",
	1: "Start",
	2: "End",
}

var BlockContentDataviewSortEmptyType_value = map[string]int32{
	"NotSpecified": 0,
	"Start":        1,
	"End":          2,
}

func (x BlockContentDataviewSortEmptyType) String() string {
	return proto.EnumName(BlockContentDataviewSortEmptyType_name, int32(x))
}

func (BlockContentDataviewSortEmptyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 2, 1}
}

type BlockContentDataviewFilterOperator int32

const (
	BlockContentDataviewFilter_No  BlockContentDataviewFilterOperator = 0
	BlockContentDataviewFilter_Or  BlockContentDataviewFilterOperator = 1
	BlockContentDataviewFilter_And BlockContentDataviewFilterOperator = 2
)

var BlockContentDataviewFilterOperator_name = map[int32]string{
	0: "No",
	1: "Or",
	2: "And",
}

var BlockContentDataviewFilterOperator_value = map[string]int32{
	"No":  0,
	"Or":  1,
	"And": 2,
}

func (x BlockContentDataviewFilterOperator) String() string {
	return proto.EnumName(BlockContentDataviewFilterOperator_name, int32(x))
}

func (BlockContentDataviewFilterOperator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 3, 0}
}

type BlockContentDataviewFilterCondition int32

const (
	BlockContentDataviewFilter_None           BlockContentDataviewFilterCondition = 0
	BlockContentDataviewFilter_Equal          BlockContentDataviewFilterCondition = 1
	BlockContentDataviewFilter_NotEqual       BlockContentDataviewFilterCondition = 2
	BlockContentDataviewFilter_Greater        BlockContentDataviewFilterCondition = 3
	BlockContentDataviewFilter_Less           BlockContentDataviewFilterCondition = 4
	BlockContentDataviewFilter_GreaterOrEqual BlockContentDataviewFilterCondition = 5
	BlockContentDataviewFilter_LessOrEqual    BlockContentDataviewFilterCondition = 6
	BlockContentDataviewFilter_Like           BlockContentDataviewFilterCondition = 7
	BlockContentDataviewFilter_NotLike        BlockContentDataviewFilterCondition = 8
	BlockContentDataviewFilter_In             BlockContentDataviewFilterCondition = 9
	BlockContentDataviewFilter_NotIn          BlockContentDataviewFilterCondition = 10
	BlockContentDataviewFilter_Empty          BlockContentDataviewFilterCondition = 11
	BlockContentDataviewFilter_NotEmpty       BlockContentDataviewFilterCondition = 12
	BlockContentDataviewFilter_AllIn          BlockContentDataviewFilterCondition = 13
	BlockContentDataviewFilter_NotAllIn       BlockContentDataviewFilterCondition = 14
	BlockContentDataviewFilter_ExactIn        BlockContentDataviewFilterCondition = 15
	BlockContentDataviewFilter_NotExactIn     BlockContentDataviewFilterCondition = 16
	BlockContentDataviewFilter_Exists         BlockContentDataviewFilterCondition = 17
)

var BlockContentDataviewFilterCondition_name = map[int32]string{
	0:  "None",
	1:  "Equal",
	2:  "NotEqual",
	3:  "Greater",
	4:  "Less",
	5:  "GreaterOrEqual",
	6:  "LessOrEqual",
	7:  "Like",
	8:  "NotLike",
	9:  "In",
	10: "NotIn",
	11: "Empty",
	12: "NotEmpty",
	13: "AllIn",
	14: "NotAllIn",
	15: "ExactIn",
	16: "NotExactIn",
	17: "Exists",
}

var BlockContentDataviewFilterCondition_value = map[string]int32{
	"None":           0,
	"Equal":          1,
	"NotEqual":       2,
	"Greater":        3,
	"Less":           4,
	"GreaterOrEqual": 5,
	"LessOrEqual":    6,
	"Like":           7,
	"NotLike":        8,
	"In":             9,
	"NotIn":          10,
	"Empty":          11,
	"NotEmpty":       12,
	"AllIn":          13,
	"NotAllIn":       14,
	"ExactIn":        15,
	"NotExactIn":     16,
	"Exists":         17,
}

func (x BlockContentDataviewFilterCondition) String() string {
	return proto.EnumName(BlockContentDataviewFilterCondition_name, int32(x))
}

func (BlockContentDataviewFilterCondition) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 3, 1}
}

type BlockContentDataviewFilterQuickOption int32

const (
	BlockContentDataviewFilter_ExactDate       BlockContentDataviewFilterQuickOption = 0
	BlockContentDataviewFilter_Yesterday       BlockContentDataviewFilterQuickOption = 1
	BlockContentDataviewFilter_Today           BlockContentDataviewFilterQuickOption = 2
	BlockContentDataviewFilter_Tomorrow        BlockContentDataviewFilterQuickOption = 3
	BlockContentDataviewFilter_LastWeek        BlockContentDataviewFilterQuickOption = 4
	BlockContentDataviewFilter_CurrentWeek     BlockContentDataviewFilterQuickOption = 5
	BlockContentDataviewFilter_NextWeek        BlockContentDataviewFilterQuickOption = 6
	BlockContentDataviewFilter_LastMonth       BlockContentDataviewFilterQuickOption = 7
	BlockContentDataviewFilter_CurrentMonth    BlockContentDataviewFilterQuickOption = 8
	BlockContentDataviewFilter_NextMonth       BlockContentDataviewFilterQuickOption = 9
	BlockContentDataviewFilter_NumberOfDaysAgo BlockContentDataviewFilterQuickOption = 10
	BlockContentDataviewFilter_NumberOfDaysNow BlockContentDataviewFilterQuickOption = 11
	BlockContentDataviewFilter_LastYear        BlockContentDataviewFilterQuickOption = 12
	BlockContentDataviewFilter_CurrentYear     BlockContentDataviewFilterQuickOption = 13
	BlockContentDataviewFilter_NextYear        BlockContentDataviewFilterQuickOption = 14
)

var BlockContentDataviewFilterQuickOption_name = map[int32]string{
	0:  "ExactDate",
	1:  "Yesterday",
	2:  "Today",
	3:  "Tomorrow",
	4:  "LastWeek",
	5:  "CurrentWeek",
	6:  "NextWeek",
	7:  "LastMonth",
	8:  "CurrentMonth",
	9:  "NextMonth",
	10: "NumberOfDaysAgo",
	11: "NumberOfDaysNow",
	12: "LastYear",
	13: "CurrentYear",
	14: "NextYear",
}

var BlockContentDataviewFilterQuickOption_value = map[string]int32{
	"ExactDate":       0,
	"Yesterday":       1,
	"Today":           2,
	"Tomorrow":        3,
	"LastWeek":        4,
	"CurrentWeek":     5,
	"NextWeek":        6,
	"LastMonth":       7,
	"CurrentMonth":    8,
	"NextMonth":       9,
	"NumberOfDaysAgo": 10,
	"NumberOfDaysNow": 11,
	"LastYear":        12,
	"CurrentYear":     13,
	"NextYear":        14,
}

func (x BlockContentDataviewFilterQuickOption) String() string {
	return proto.EnumName(BlockContentDataviewFilterQuickOption_name, int32(x))
}

func (BlockContentDataviewFilterQuickOption) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 9, 3, 2}
}

type BlockContentLatexProcessor int32

const (
	BlockContentLatex_Latex         BlockContentLatexProcessor = 0
	BlockContentLatex_Mermaid       BlockContentLatexProcessor = 1
	BlockContentLatex_Chart         BlockContentLatexProcessor = 2
	BlockContentLatex_Youtube       BlockContentLatexProcessor = 3
	BlockContentLatex_Vimeo         BlockContentLatexProcessor = 4
	BlockContentLatex_Soundcloud    BlockContentLatexProcessor = 5
	BlockContentLatex_GoogleMaps    BlockContentLatexProcessor = 6
	BlockContentLatex_Miro          BlockContentLatexProcessor = 7
	BlockContentLatex_Figma         BlockContentLatexProcessor = 8
	BlockContentLatex_Twitter       BlockContentLatexProcessor = 9
	BlockContentLatex_OpenStreetMap BlockContentLatexProcessor = 10
	BlockContentLatex_Reddit        BlockContentLatexProcessor = 11
	BlockContentLatex_Facebook      BlockContentLatexProcessor = 12
	BlockContentLatex_Instagram     BlockContentLatexProcessor = 13
	BlockContentLatex_Telegram      BlockContentLatexProcessor = 14
	BlockContentLatex_GithubGist    BlockContentLatexProcessor = 15
	BlockContentLatex_Codepen       BlockContentLatexProcessor = 16
	BlockContentLatex_Bilibili      BlockContentLatexProcessor = 17
	BlockContentLatex_Excalidraw    BlockContentLatexProcessor = 18
	BlockContentLatex_Kroki         BlockContentLatexProcessor = 19
	BlockContentLatex_Graphviz      BlockContentLatexProcessor = 20
	BlockContentLatex_Sketchfab     BlockContentLatexProcessor = 21
	BlockContentLatex_Image         BlockContentLatexProcessor = 22
	BlockContentLatex_Drawio        BlockContentLatexProcessor = 23
	BlockContentLatex_Spotify       BlockContentLatexProcessor = 24
)

var BlockContentLatexProcessor_name = map[int32]string{
	0:  "Latex",
	1:  "Mermaid",
	2:  "Chart",
	3:  "Youtube",
	4:  "Vimeo",
	5:  "Soundcloud",
	6:  "GoogleMaps",
	7:  "Miro",
	8:  "Figma",
	9:  "Twitter",
	10: "OpenStreetMap",
	11: "Reddit",
	12: "Facebook",
	13: "Instagram",
	14: "Telegram",
	15: "GithubGist",
	16: "Codepen",
	17: "Bilibili",
	18: "Excalidraw",
	19: "Kroki",
	20: "Graphviz",
	21: "Sketchfab",
	22: "Image",
	23: "Drawio",
	24: "Spotify",
}

var BlockContentLatexProcessor_value = map[string]int32{
	"Latex":         0,
	"Mermaid":       1,
	"Chart":         2,
	"Youtube":       3,
	"Vimeo":         4,
	"Soundcloud":    5,
	"GoogleMaps":    6,
	"Miro":          7,
	"Figma":         8,
	"Twitter":       9,
	"OpenStreetMap": 10,
	"Reddit":        11,
	"Facebook":      12,
	"Instagram":     13,
	"Telegram":      14,
	"GithubGist":    15,
	"Codepen":       16,
	"Bilibili":      17,
	"Excalidraw":    18,
	"Kroki":         19,
	"Graphviz":      20,
	"Sketchfab":     21,
	"Image":         22,
	"Drawio":        23,
	"Spotify":       24,
}

func (x BlockContentLatexProcessor) String() string {
	return proto.EnumName(BlockContentLatexProcessor_name, int32(x))
}

func (BlockContentLatexProcessor) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 11, 0}
}

type BlockContentWidgetLayout int32

const (
	BlockContentWidget_Link        BlockContentWidgetLayout = 0
	BlockContentWidget_Tree        BlockContentWidgetLayout = 1
	BlockContentWidget_List        BlockContentWidgetLayout = 2
	BlockContentWidget_CompactList BlockContentWidgetLayout = 3
	BlockContentWidget_View        BlockContentWidgetLayout = 4
)

var BlockContentWidgetLayout_name = map[int32]string{
	0: "Link",
	1: "Tree",
	2: "List",
	3: "CompactList",
	4: "View",
}

var BlockContentWidgetLayout_value = map[string]int32{
	"Link":        0,
	"Tree":        1,
	"List":        2,
	"CompactList": 3,
	"View":        4,
}

func (x BlockContentWidgetLayout) String() string {
	return proto.EnumName(BlockContentWidgetLayout_name, int32(x))
}

func (BlockContentWidgetLayout) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{2, 1, 16, 0}
}

type AccountStatusType int32

const (
	Account_Active          AccountStatusType = 0
	Account_PendingDeletion AccountStatusType = 1
	Account_StartedDeletion AccountStatusType = 2
	Account_Deleted         AccountStatusType = 3
)

var AccountStatusType_name = map[int32]string{
	0: "Active",
	1: "PendingDeletion",
	2: "StartedDeletion",
	3: "Deleted",
}

var AccountStatusType_value = map[string]int32{
	"Active":          0,
	"PendingDeletion": 1,
	"StartedDeletion": 2,
	"Deleted":         3,
}

func (x AccountStatusType) String() string {
	return proto.EnumName(AccountStatusType_name, int32(x))
}

func (AccountStatusType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{5, 0}
}

type AccountAuthLocalApiScope int32

const (
	AccountAuth_Limited AccountAuthLocalApiScope = 0
	AccountAuth_JsonAPI AccountAuthLocalApiScope = 1
	AccountAuth_Full    AccountAuthLocalApiScope = 2
)

var AccountAuthLocalApiScope_name = map[int32]string{
	0: "Limited",
	1: "JsonAPI",
	2: "Full",
}

var AccountAuthLocalApiScope_value = map[string]int32{
	"Limited": 0,
	"JsonAPI": 1,
	"Full":    2,
}

func (x AccountAuthLocalApiScope) String() string {
	return proto.EnumName(AccountAuthLocalApiScope_name, int32(x))
}

func (AccountAuthLocalApiScope) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{5, 3, 0}
}

type LinkPreviewType int32

const (
	LinkPreview_Unknown LinkPreviewType = 0
	LinkPreview_Page    LinkPreviewType = 1
	LinkPreview_Image   LinkPreviewType = 2
	LinkPreview_Text    LinkPreviewType = 3
)

var LinkPreviewType_name = map[int32]string{
	0: "Unknown",
	1: "Page",
	2: "Image",
	3: "Text",
}

var LinkPreviewType_value = map[string]int32{
	"Unknown": 0,
	"Page":    1,
	"Image":   2,
	"Text":    3,
}

func (x LinkPreviewType) String() string {
	return proto.EnumName(LinkPreviewType_name, int32(x))
}

func (LinkPreviewType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{6, 0}
}

type RestrictionsObjectRestriction int32

const (
	Restrictions_None RestrictionsObjectRestriction = 0
	// restricts delete
	Restrictions_Delete RestrictionsObjectRestriction = 1
	// restricts work with relations
	Restrictions_Relations RestrictionsObjectRestriction = 2
	// restricts work with blocks
	Restrictions_Blocks RestrictionsObjectRestriction = 3
	// restricts work with details
	Restrictions_Details RestrictionsObjectRestriction = 4
	// restricts type changing
	Restrictions_TypeChange RestrictionsObjectRestriction = 5
	// restricts layout changing
	Restrictions_LayoutChange RestrictionsObjectRestriction = 6
	// restricts template creation from this object
	Restrictions_Template RestrictionsObjectRestriction = 7
	// restricts duplicate object
	Restrictions_Duplicate RestrictionsObjectRestriction = 8
	// can be set only for types. Restricts creating objects of this type
	Restrictions_CreateObjectOfThisType RestrictionsObjectRestriction = 9
	// object is not allowed to publish
	Restrictions_Publish RestrictionsObjectRestriction = 10
)

var RestrictionsObjectRestriction_name = map[int32]string{
	0:  "None",
	1:  "Delete",
	2:  "Relations",
	3:  "Blocks",
	4:  "Details",
	5:  "TypeChange",
	6:  "LayoutChange",
	7:  "Template",
	8:  "Duplicate",
	9:  "CreateObjectOfThisType",
	10: "Publish",
}

var RestrictionsObjectRestriction_value = map[string]int32{
	"None":                   0,
	"Delete":                 1,
	"Relations":              2,
	"Blocks":                 3,
	"Details":                4,
	"TypeChange":             5,
	"LayoutChange":           6,
	"Template":               7,
	"Duplicate":              8,
	"CreateObjectOfThisType": 9,
	"Publish":                10,
}

func (x RestrictionsObjectRestriction) String() string {
	return proto.EnumName(RestrictionsObjectRestriction_name, int32(x))
}

func (RestrictionsObjectRestriction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{7, 0}
}

type RestrictionsDataviewRestriction int32

const (
	Restrictions_DVNone         RestrictionsDataviewRestriction = 0
	Restrictions_DVRelation     RestrictionsDataviewRestriction = 1
	Restrictions_DVCreateObject RestrictionsDataviewRestriction = 2
	Restrictions_DVViews        RestrictionsDataviewRestriction = 3
)

var RestrictionsDataviewRestriction_name = map[int32]string{
	0: "DVNone",
	1: "DVRelation",
	2: "DVCreateObject",
	3: "DVViews",
}

var RestrictionsDataviewRestriction_value = map[string]int32{
	"DVNone":         0,
	"DVRelation":     1,
	"DVCreateObject": 2,
	"DVViews":        3,
}

func (x RestrictionsDataviewRestriction) String() string {
	return proto.EnumName(RestrictionsDataviewRestriction_name, int32(x))
}

func (RestrictionsDataviewRestriction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{7, 1}
}

type ObjectTypeLayout int32

const (
	ObjectType_basic               ObjectTypeLayout = 0
	ObjectType_profile             ObjectTypeLayout = 1
	ObjectType_todo                ObjectTypeLayout = 2
	ObjectType_set                 ObjectTypeLayout = 3
	ObjectType_objectType          ObjectTypeLayout = 4
	ObjectType_relation            ObjectTypeLayout = 5
	ObjectType_file                ObjectTypeLayout = 6
	ObjectType_dashboard           ObjectTypeLayout = 7
	ObjectType_image               ObjectTypeLayout = 8
	ObjectType_note                ObjectTypeLayout = 9
	ObjectType_space               ObjectTypeLayout = 10
	ObjectType_bookmark            ObjectTypeLayout = 11
	ObjectType_relationOptionsList ObjectTypeLayout = 12
	ObjectType_relationOption      ObjectTypeLayout = 13
	ObjectType_collection          ObjectTypeLayout = 14
	ObjectType_audio               ObjectTypeLayout = 15
	ObjectType_video               ObjectTypeLayout = 16
	ObjectType_date                ObjectTypeLayout = 17
	ObjectType_spaceView           ObjectTypeLayout = 18
	ObjectType_participant         ObjectTypeLayout = 19
	ObjectType_pdf                 ObjectTypeLayout = 20
	ObjectType_chatDeprecated      ObjectTypeLayout = 21
	ObjectType_chatDerived         ObjectTypeLayout = 22
	ObjectType_tag                 ObjectTypeLayout = 23
	ObjectType_notification        ObjectTypeLayout = 24
	ObjectType_missingObject       ObjectTypeLayout = 25
	ObjectType_devices             ObjectTypeLayout = 26
)

var ObjectTypeLayout_name = map[int32]string{
	0:  "basic",
	1:  "profile",
	2:  "todo",
	3:  "set",
	4:  "objectType",
	5:  "relation",
	6:  "file",
	7:  "dashboard",
	8:  "image",
	9:  "note",
	10: "space",
	11: "bookmark",
	12: "relationOptionsList",
	13: "relationOption",
	14: "collection",
	15: "audio",
	16: "video",
	17: "date",
	18: "spaceView",
	19: "participant",
	20: "pdf",
	21: "chatDeprecated",
	22: "chatDerived",
	23: "tag",
	24: "notification",
	25: "missingObject",
	26: "devices",
}

var ObjectTypeLayout_value = map[string]int32{
	"basic":               0,
	"profile":             1,
	"todo":                2,
	"set":                 3,
	"objectType":          4,
	"relation":            5,
	"file":                6,
	"dashboard":           7,
	"image":               8,
	"note":                9,
	"space":               10,
	"bookmark":            11,
	"relationOptionsList": 12,
	"relationOption":      13,
	"collection":          14,
	"audio":               15,
	"video":               16,
	"date":                17,
	"spaceView":           18,
	"participant":         19,
	"pdf":                 20,
	"chatDeprecated":      21,
	"chatDerived":         22,
	"tag":                 23,
	"notification":        24,
	"missingObject":       25,
	"devices":             26,
}

func (x ObjectTypeLayout) String() string {
	return proto.EnumName(ObjectTypeLayout_name, int32(x))
}

func (ObjectTypeLayout) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{10, 0}
}

type RelationScope int32

const (
	Relation_object               RelationScope = 0
	Relation_type                 RelationScope = 1
	Relation_setOfTheSameType     RelationScope = 2
	Relation_objectsOfTheSameType RelationScope = 3
	Relation_library              RelationScope = 4
)

var RelationScope_name = map[int32]string{
	0: "object",
	1: "type",
	2: "setOfTheSameType",
	3: "objectsOfTheSameType",
	4: "library",
}

var RelationScope_value = map[string]int32{
	"object":               0,
	"type":                 1,
	"setOfTheSameType":     2,
	"objectsOfTheSameType": 3,
	"library":              4,
}

func (x RelationScope) String() string {
	return proto.EnumName(RelationScope_name, int32(x))
}

func (RelationScope) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{13, 0}
}

type RelationDataSource int32

const (
	Relation_details RelationDataSource = 0
	Relation_derived RelationDataSource = 1
	Relation_account RelationDataSource = 2
	Relation_local   RelationDataSource = 3
)

var RelationDataSource_name = map[int32]string{
	0: "details",
	1: "derived",
	2: "account",
	3: "local",
}

var RelationDataSource_value = map[string]int32{
	"details": 0,
	"derived": 1,
	"account": 2,
	"local":   3,
}

func (x RelationDataSource) String() string {
	return proto.EnumName(RelationDataSource_name, int32(x))
}

func (RelationDataSource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{13, 1}
}

// Use such a weird construction due to the issue with imported repeated enum type
// Look https://github.com/golang/protobuf/issues/1135 for more information.
type InternalFlagValue int32

const (
	InternalFlag_editorDeleteEmpty        InternalFlagValue = 0
	InternalFlag_editorSelectType         InternalFlagValue = 1
	InternalFlag_editorSelectTemplate     InternalFlagValue = 2
	InternalFlag_collectionDontIndexLinks InternalFlagValue = 3
)

var InternalFlagValue_name = map[int32]string{
	0: "editorDeleteEmpty",
	1: "editorSelectType",
	2: "editorSelectTemplate",
	3: "collectionDontIndexLinks",
}

var InternalFlagValue_value = map[string]int32{
	"editorDeleteEmpty":        0,
	"editorSelectType":         1,
	"editorSelectTemplate":     2,
	"collectionDontIndexLinks": 3,
}

func (x InternalFlagValue) String() string {
	return proto.EnumName(InternalFlagValue_name, int32(x))
}

func (InternalFlagValue) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{17, 0}
}

type NotificationStatus int32

const (
	Notification_Created NotificationStatus = 0
	Notification_Shown   NotificationStatus = 1
	Notification_Read    NotificationStatus = 2
	Notification_Replied NotificationStatus = 3
)

var NotificationStatus_name = map[int32]string{
	0: "Created",
	1: "Shown",
	2: "Read",
	3: "Replied",
}

var NotificationStatus_value = map[string]int32{
	"Created": 0,
	"Shown":   1,
	"Read":    2,
	"Replied": 3,
}

func (x NotificationStatus) String() string {
	return proto.EnumName(NotificationStatus_name, int32(x))
}

func (NotificationStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{21, 0}
}

type NotificationActionType int32

const (
	Notification_CLOSE NotificationActionType = 0
)

var NotificationActionType_name = map[int32]string{
	0: "CLOSE",
}

var NotificationActionType_value = map[string]int32{
	"CLOSE": 0,
}

func (x NotificationActionType) String() string {
	return proto.EnumName(NotificationActionType_name, int32(x))
}

func (NotificationActionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{21, 1}
}

type NotificationExportCode int32

const (
	NotificationExport_NULL          NotificationExportCode = 0
	NotificationExport_UNKNOWN_ERROR NotificationExportCode = 1
	NotificationExport_BAD_INPUT     NotificationExportCode = 2
)

var NotificationExportCode_name = map[int32]string{
	0: "NULL",
	1: "UNKNOWN_ERROR",
	2: "BAD_INPUT",
}

var NotificationExportCode_value = map[string]int32{
	"NULL":          0,
	"UNKNOWN_ERROR": 1,
	"BAD_INPUT":     2,
}

func (x NotificationExportCode) String() string {
	return proto.EnumName(NotificationExportCode_name, int32(x))
}

func (NotificationExportCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{21, 1, 0}
}

type ExportFormat int32

const (
	Export_Markdown   ExportFormat = 0
	Export_Protobuf   ExportFormat = 1
	Export_JSON       ExportFormat = 2
	Export_DOT        ExportFormat = 3
	Export_SVG        ExportFormat = 4
	Export_GRAPH_JSON ExportFormat = 5
)

var ExportFormat_name = map[int32]string{
	0: "Markdown",
	1: "Protobuf",
	2: "JSON",
	3: "DOT",
	4: "SVG",
	5: "GRAPH_JSON",
}

var ExportFormat_value = map[string]int32{
	"Markdown":   0,
	"Protobuf":   1,
	"JSON":       2,
	"DOT":        3,
	"SVG":        4,
	"GRAPH_JSON": 5,
}

func (x ExportFormat) String() string {
	return proto.EnumName(ExportFormat_name, int32(x))
}

func (ExportFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{22, 0}
}

type ImportType int32

const (
	Import_Notion   ImportType = 0
	Import_Markdown ImportType = 1
	Import_External ImportType = 2
	Import_Pb       ImportType = 3
	Import_Html     ImportType = 4
	Import_Txt      ImportType = 5
	Import_Csv      ImportType = 6
	Import_Obsidian ImportType = 7
)

var ImportType_name = map[int32]string{
	0: "Notion",
	1: "Markdown",
	2: "External",
	3: "Pb",
	4: "Html",
	5: "Txt",
	6: "Csv",
	7: "Obsidian",
}

var ImportType_value = map[string]int32{
	"Notion":   0,
	"Markdown": 1,
	"External": 2,
	"Pb":       3,
	"Html":     4,
	"Txt":      5,
	"Csv":      6,
	"Obsidian": 7,
}

func (x ImportType) String() string {
	return proto.EnumName(ImportType_name, int32(x))
}

func (ImportType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{23, 0}
}

type ImportErrorCode int32

const (
	Import_NULL                                    ImportErrorCode = 0
	Import_UNKNOWN_ERROR                           ImportErrorCode = 1
	Import_BAD_INPUT                               ImportErrorCode = 2
	Import_INTERNAL_ERROR                          ImportErrorCode = 3
	Import_FILE_LOAD_ERROR                         ImportErrorCode = 8
	Import_IMPORT_IS_CANCELED                      ImportErrorCode = 6
	Import_NOTION_NO_OBJECTS_IN_INTEGRATION        ImportErrorCode = 5
	Import_NOTION_SERVER_IS_UNAVAILABLE            ImportErrorCode = 12
	Import_NOTION_RATE_LIMIT_EXCEEDED              ImportErrorCode = 13
	Import_FILE_IMPORT_NO_OBJECTS_IN_ZIP_ARCHIVE   ImportErrorCode = 14
	Import_FILE_IMPORT_NO_OBJECTS_IN_DIRECTORY     ImportErrorCode = 17
	Import_HTML_WRONG_HTML_STRUCTURE               ImportErrorCode = 10
	Import_PB_NOT_ANYBLOCK_FORMAT                  ImportErrorCode = 11
	Import_CSV_LIMIT_OF_ROWS_OR_RELATIONS_EXCEEDED ImportErrorCode = 7
	Import_INSUFFICIENT_PERMISSIONS                ImportErrorCode = 9
)

var ImportErrorCode_name = map[int32]string{
	0:  "NULL",
	1:  "UNKNOWN_ERROR",
	2:  "BAD_INPUT",
	3:  "INTERNAL_ERROR",
	8:  "FILE_LOAD_ERROR",
	6:  "IMPORT_IS_CANCELED",
	5:  "NOTION_NO_OBJECTS_IN_INTEGRATION",
	12: "NOTION_SERVER_IS_UNAVAILABLE",
	13: "NOTION_RATE_LIMIT_EXCEEDED",
	14: "FILE_IMPORT_NO_OBJECTS_IN_ZIP_ARCHIVE",
	17: "FILE_IMPORT_NO_OBJECTS_IN_DIRECTORY",
	10: "HTML_WRONG_HTML_STRUCTURE",
	11: "PB_NOT_ANYBLOCK_FORMAT",
	7:  "CSV_LIMIT_OF_ROWS_OR_RELATIONS_EXCEEDED",
	9:  "INSUFFICIENT_PERMISSIONS",
}

var ImportErrorCode_value = map[string]int32{
	"NULL":                                    0,
	"UNKNOWN_ERROR":                           1,
	"BAD_INPUT":                               2,
	"INTERNAL_ERROR":                          3,
	"FILE_LOAD_ERROR":                         8,
	"IMPORT_IS_CANCELED":                      6,
	"NOTION_NO_OBJECTS_IN_INTEGRATION":        5,
	"NOTION_SERVER_IS_UNAVAILABLE":            12,
	"NOTION_RATE_LIMIT_EXCEEDED":              13,
	"FILE_IMPORT_NO_OBJECTS_IN_ZIP_ARCHIVE":   14,
	"FILE_IMPORT_NO_OBJECTS_IN_DIRECTORY":     17,
	"HTML_WRONG_HTML_STRUCTURE":               10,
	"PB_NOT_ANYBLOCK_FORMAT":                  11,
	"CSV_LIMIT_OF_ROWS_OR_RELATIONS_EXCEEDED": 7,
	"INSUFFICIENT_PERMISSIONS":                9,
}

func (x ImportErrorCode) String() string {
	return proto.EnumName(ImportErrorCode_name, int32(x))
}

func (ImportErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{23, 1}
}

type MembershipStatus int32

const (
	Membership_StatusUnknown MembershipStatus = 0
	// please wait a bit more, we are still processing your request
	// the payment is confirmed, but we need more time to do some side-effects:
	// - increase limits
	// - send emails
	// - allocate names
	Membership_StatusPending MembershipStatus = 1
	// the membership is active, ready to use!
	Membership_StatusActive MembershipStatus = 2
	// in some cases we need to finalize the process:
	// - if user has bought membership directly without first calling
	// the BuySubscription method
	// in this case please call Finalize to finish the process
	Membership_StatusPendingRequiresFinalization MembershipStatus = 3
)

var MembershipStatus_name = map[int32]string{
	0: "StatusUnknown",
	1: "StatusPending",
	2: "StatusActive",
	3: "StatusPendingRequiresFinalization",
}

var MembershipStatus_value = map[string]int32{
	"StatusUnknown":                     0,
	"StatusPending":                     1,
	"StatusActive":                      2,
	"StatusPendingRequiresFinalization": 3,
}

func (x MembershipStatus) String() string {
	return proto.EnumName(MembershipStatus_name, int32(x))
}

func (MembershipStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{30, 0}
}

type MembershipPaymentMethod int32

const (
	Membership_MethodNone        MembershipPaymentMethod = 0
	Membership_MethodStripe      MembershipPaymentMethod = 1
	Membership_MethodCrypto      MembershipPaymentMethod = 2
	Membership_MethodInappApple  MembershipPaymentMethod = 3
	Membership_MethodInappGoogle MembershipPaymentMethod = 4
)

var MembershipPaymentMethod_name = map[int32]string{
	0: "MethodNone",
	1: "MethodStripe",
	2: "MethodCrypto",
	3: "MethodInappApple",
	4: "MethodInappGoogle",
}

var MembershipPaymentMethod_value = map[string]int32{
	"MethodNone":        0,
	"MethodStripe":      1,
	"MethodCrypto":      2,
	"MethodInappApple":  3,
	"MethodInappGoogle": 4,
}

func (x MembershipPaymentMethod) String() string {
	return proto.EnumName(MembershipPaymentMethod_name, int32(x))
}

func (MembershipPaymentMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{30, 1}
}

type MembershipEmailVerificationStatus int32

const (
	// user NEVER comleted the verification of the email
	Membership_StatusNotVerified MembershipEmailVerificationStatus = 0
	// user has asked for new code, but did not enter it yet
	// (even if email was verified before, you can ask to UPDATE your e-mail)
	// please wait, you can not ask for more codes yet
	Membership_StatusCodeSent MembershipEmailVerificationStatus = 1
	// the e-mail is finally verified
	Membership_StatusVerified MembershipEmailVerificationStatus = 2
)

var MembershipEmailVerificationStatus_name = map[int32]string{
	0: "StatusNotVerified",
	1: "StatusCodeSent",
	2: "StatusVerified",
}

var MembershipEmailVerificationStatus_value = map[string]int32{
	"StatusNotVerified": 0,
	"StatusCodeSent":    1,
	"StatusVerified":    2,
}

func (x MembershipEmailVerificationStatus) String() string {
	return proto.EnumName(MembershipEmailVerificationStatus_name, int32(x))
}

func (MembershipEmailVerificationStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{30, 2}
}

type MembershipTierDataPeriodType int32

const (
	MembershipTierData_PeriodTypeUnknown   MembershipTierDataPeriodType = 0
	MembershipTierData_PeriodTypeUnlimited MembershipTierDataPeriodType = 1
	MembershipTierData_PeriodTypeDays      MembershipTierDataPeriodType = 2
	MembershipTierData_PeriodTypeWeeks     MembershipTierDataPeriodType = 3
	MembershipTierData_PeriodTypeMonths    MembershipTierDataPeriodType = 4
	MembershipTierData_PeriodTypeYears     MembershipTierDataPeriodType = 5
)

var MembershipTierDataPeriodType_name = map[int32]string{
	0: "PeriodTypeUnknown",
	1: "PeriodTypeUnlimited",
	2: "PeriodTypeDays",
	3: "PeriodTypeWeeks",
	4: "PeriodTypeMonths",
	5: "PeriodTypeYears",
}

var MembershipTierDataPeriodType_value = map[string]int32{
	"PeriodTypeUnknown":   0,
	"PeriodTypeUnlimited": 1,
	"PeriodTypeDays":      2,
	"PeriodTypeWeeks":     3,
	"PeriodTypeMonths":    4,
	"PeriodTypeYears":     5,
}

func (x MembershipTierDataPeriodType) String() string {
	return proto.EnumName(MembershipTierDataPeriodType_name, int32(x))
}

func (MembershipTierDataPeriodType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{31, 0}
}

type ChatMessageAttachmentAttachmentType int32

const (
	ChatMessageAttachment_FILE  ChatMessageAttachmentAttachmentType = 0
	ChatMessageAttachment_IMAGE ChatMessageAttachmentAttachmentType = 1
	ChatMessageAttachment_LINK  ChatMessageAttachmentAttachmentType = 2
)

var ChatMessageAttachmentAttachmentType_name = map[int32]string{
	0: "FILE",
	1: "IMAGE",
	2: "LINK",
}

var ChatMessageAttachmentAttachmentType_value = map[string]int32{
	"FILE":  0,
	"IMAGE": 1,
	"LINK":  2,
}

func (x ChatMessageAttachmentAttachmentType) String() string {
	return proto.EnumName(ChatMessageAttachmentAttachmentType_name, int32(x))
}

func (ChatMessageAttachmentAttachmentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{35, 1, 0}
}

type SmartBlockSnapshotBase struct {
	Blocks                   []*Block        `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
	Details                  *types.Struct   `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	FileKeys                 *types.Struct   `protobuf:"bytes,3,opt,name=fileKeys,proto3" json:"fileKeys,omitempty"`             // Deprecated: Do not use.
	ExtraRelations           []*Relation     `protobuf:"bytes,4,rep,name=extraRelations,proto3" json:"extraRelations,omitempty"` // Deprecated: Do not use.
	ObjectTypes              []string        `protobuf:"bytes,5,rep,name=objectTypes,proto3" json:"objectTypes,omitempty"`
	Collections              *types.Struct   `protobuf:"bytes,6,opt,name=collections,proto3" json:"collections,omitempty"`
	RemovedCollectionKeys    []string        `protobuf:"bytes,8,rep,name=removedCollectionKeys,proto3" json:"removedCollectionKeys,omitempty"`
	RelationLinks            []*RelationLink `protobuf:"bytes,7,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
	Key                      string          `protobuf:"bytes,9,opt,name=key,proto3" json:"key,omitempty"`
	OriginalCreatedTimestamp int64           `protobuf:"varint,10,opt,name=originalCreatedTimestamp,proto3" json:"originalCreatedTimestamp,omitempty"`
	FileInfo                 *FileInfo       `protobuf:"bytes,11,opt,name=fileInfo,proto3" json:"fileInfo,omitempty"`
}

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

var xxx_messageInfo_SmartBlockSnapshotBase proto.InternalMessageInfo

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

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

// Deprecated: Do not use.
func (m *SmartBlockSnapshotBase) GetFileKeys() *types.Struct {
	if m != nil {
		return m.FileKeys
	}
	return nil
}

// Deprecated: Do not use.
func (m *SmartBlockSnapshotBase) GetExtraRelations() []*Relation {
	if m != nil {
		return m.ExtraRelations
	}
	return nil
}

func (m *SmartBlockSnapshotBase) GetObjectTypes() []string {
	if m != nil {
		return m.ObjectTypes
	}
	return nil
}

func (m *SmartBlockSnapshotBase) GetCollections() *types.Struct {
	if m != nil {
		return m.Collections
	}
	return nil
}

func (m *SmartBlockSnapshotBase) GetRemovedCollectionKeys() []string {
	if m != nil {
		return m.RemovedCollectionKeys
	}
	return nil
}

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

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

func (m *SmartBlockSnapshotBase) GetOriginalCreatedTimestamp() int64 {
	if m != nil {
		return m.OriginalCreatedTimestamp
	}
	return 0
}

func (m *SmartBlockSnapshotBase) GetFileInfo() *FileInfo {
	if m != nil {
		return m.FileInfo
	}
	return nil
}

type Search struct {
}

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

var xxx_messageInfo_Search proto.InternalMessageInfo

type SearchResult struct {
	ObjectId string        `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Details  *types.Struct `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	Meta     []*SearchMeta `protobuf:"bytes,3,rep,name=meta,proto3" json:"meta,omitempty"`
}

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

var xxx_messageInfo_SearchResult proto.InternalMessageInfo

func (m *SearchResult) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	return ""
}

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

func (m *SearchResult) GetMeta() []*SearchMeta {
	if m != nil {
		return m.Meta
	}
	return nil
}

type SearchMeta struct {
	Highlight       string        `protobuf:"bytes,1,opt,name=highlight,proto3" json:"highlight,omitempty"`
	HighlightRanges []*Range      `protobuf:"bytes,2,rep,name=highlightRanges,proto3" json:"highlightRanges,omitempty"`
	BlockId         string        `protobuf:"bytes,3,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RelationKey     string        `protobuf:"bytes,4,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	RelationDetails *types.Struct `protobuf:"bytes,5,opt,name=relationDetails,proto3" json:"relationDetails,omitempty"`
}

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

var xxx_messageInfo_SearchMeta proto.InternalMessageInfo

func (m *SearchMeta) GetHighlight() string {
	if m != nil {
		return m.Highlight
	}
	return ""
}

func (m *SearchMeta) GetHighlightRanges() []*Range {
	if m != nil {
		return m.HighlightRanges
	}
	return nil
}

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

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

func (m *SearchMeta) GetRelationDetails() *types.Struct {
	if m != nil {
		return m.RelationDetails
	}
	return nil
}

type Block 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"`
	Restrictions    *BlockRestrictions `protobuf:"bytes,3,opt,name=restrictions,proto3" json:"restrictions,omitempty"`
	ChildrenIds     []string           `protobuf:"bytes,4,rep,name=childrenIds,proto3" json:"childrenIds,omitempty"`
	BackgroundColor string             `protobuf:"bytes,5,opt,name=backgroundColor,proto3" json:"backgroundColor,omitempty"`
	Align           BlockAlign         `protobuf:"varint,6,opt,name=align,proto3,enum=anytype.model.BlockAlign" json:"align,omitempty"`
	VerticalAlign   BlockVerticalAlign `protobuf:"varint,7,opt,name=verticalAlign,proto3,enum=anytype.model.BlockVerticalAlign" json:"verticalAlign,omitempty"`
	// Types that are valid to be assigned to Content:
	//
	//	*BlockContentOfSmartblock
	//	*BlockContentOfText
	//	*BlockContentOfFile
	//	*BlockContentOfLayout
	//	*BlockContentOfDiv
	//	*BlockContentOfBookmark
	//	*BlockContentOfIcon
	//	*BlockContentOfLink
	//	*BlockContentOfDataview
	//	*BlockContentOfRelation
	//	*BlockContentOfFeaturedRelations
	//	*BlockContentOfLatex
	//	*BlockContentOfTableOfContents
	//	*BlockContentOfTable
	//	*BlockContentOfTableColumn
	//	*BlockContentOfTableRow
	//	*BlockContentOfWidget
	//	*BlockContentOfChat
	Content IsBlockContent `protobuf_oneof:"content"`
}

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

var xxx_messageInfo_Block proto.InternalMessageInfo

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

type BlockContentOfSmartblock struct {
	Smartblock *BlockContentSmartblock `protobuf:"bytes,11,opt,name=smartblock,proto3,oneof" json:"smartblock,omitempty"`
}
type BlockContentOfText struct {
	Text *BlockContentText `protobuf:"bytes,14,opt,name=text,proto3,oneof" json:"text,omitempty"`
}
type BlockContentOfFile struct {
	File *BlockContentFile `protobuf:"bytes,15,opt,name=file,proto3,oneof" json:"file,omitempty"`
}
type BlockContentOfLayout struct {
	Layout *BlockContentLayout `protobuf:"bytes,16,opt,name=layout,proto3,oneof" json:"layout,omitempty"`
}
type BlockContentOfDiv struct {
	Div *BlockContentDiv `protobuf:"bytes,17,opt,name=div,proto3,oneof" json:"div,omitempty"`
}
type BlockContentOfBookmark struct {
	Bookmark *BlockContentBookmark `protobuf:"bytes,18,opt,name=bookmark,proto3,oneof" json:"bookmark,omitempty"`
}
type BlockContentOfIcon struct {
	Icon *BlockContentIcon `protobuf:"bytes,19,opt,name=icon,proto3,oneof" json:"icon,omitempty"`
}
type BlockContentOfLink struct {
	Link *BlockContentLink `protobuf:"bytes,20,opt,name=link,proto3,oneof" json:"link,omitempty"`
}
type BlockContentOfDataview struct {
	Dataview *BlockContentDataview `protobuf:"bytes,21,opt,name=dataview,proto3,oneof" json:"dataview,omitempty"`
}
type BlockContentOfRelation struct {
	Relation *BlockContentRelation `protobuf:"bytes,22,opt,name=relation,proto3,oneof" json:"relation,omitempty"`
}
type BlockContentOfFeaturedRelations struct {
	FeaturedRelations *BlockContentFeaturedRelations `protobuf:"bytes,23,opt,name=featuredRelations,proto3,oneof" json:"featuredRelations,omitempty"`
}
type BlockContentOfLatex struct {
	Latex *BlockContentLatex `protobuf:"bytes,24,opt,name=latex,proto3,oneof" json:"latex,omitempty"`
}
type BlockContentOfTableOfContents struct {
	TableOfContents *BlockContentTableOfContents `protobuf:"bytes,25,opt,name=tableOfContents,proto3,oneof" json:"tableOfContents,omitempty"`
}
type BlockContentOfTable struct {
	Table *BlockContentTable `protobuf:"bytes,26,opt,name=table,proto3,oneof" json:"table,omitempty"`
}
type BlockContentOfTableColumn struct {
	TableColumn *BlockContentTableColumn `protobuf:"bytes,27,opt,name=tableColumn,proto3,oneof" json:"tableColumn,omitempty"`
}
type BlockContentOfTableRow struct {
	TableRow *BlockContentTableRow `protobuf:"bytes,28,opt,name=tableRow,proto3,oneof" json:"tableRow,omitempty"`
}
type BlockContentOfWidget struct {
	Widget *BlockContentWidget `protobuf:"bytes,29,opt,name=widget,proto3,oneof" json:"widget,omitempty"`
}
type BlockContentOfChat struct {
	Chat *BlockContentChat `protobuf:"bytes,30,opt,name=chat,proto3,oneof" json:"chat,omitempty"`
}

func (*BlockContentOfSmartblock) IsBlockContent()        {}
func (*BlockContentOfText) IsBlockContent()              {}
func (*BlockContentOfFile) IsBlockContent()              {}
func (*BlockContentOfLayout) IsBlockContent()            {}
func (*BlockContentOfDiv) IsBlockContent()               {}
func (*BlockContentOfBookmark) IsBlockContent()          {}
func (*BlockContentOfIcon) IsBlockContent()              {}
func (*BlockContentOfLink) IsBlockContent()              {}
func (*BlockContentOfDataview) IsBlockContent()          {}
func (*BlockContentOfRelation) IsBlockContent()          {}
func (*BlockContentOfFeaturedRelations) IsBlockContent() {}
func (*BlockContentOfLatex) IsBlockContent()             {}
func (*BlockContentOfTableOfContents) IsBlockContent()   {}
func (*BlockContentOfTable) IsBlockContent()             {}
func (*BlockContentOfTableColumn) IsBlockContent()       {}
func (*BlockContentOfTableRow) IsBlockContent()          {}
func (*BlockContentOfWidget) IsBlockContent()            {}
func (*BlockContentOfChat) IsBlockContent()              {}

func (m *Block) GetContent() IsBlockContent {
	if m != nil {
		return m.Content
	}
	return nil
}

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

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

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

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

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

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

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

func (m *Block) GetSmartblock() *BlockContentSmartblock {
	if x, ok := m.GetContent().(*BlockContentOfSmartblock); ok {
		return x.Smartblock
	}
	return nil
}

func (m *Block) GetText() *BlockContentText {
	if x, ok := m.GetContent().(*BlockContentOfText); ok {
		return x.Text
	}
	return nil
}

func (m *Block) GetFile() *BlockContentFile {
	if x, ok := m.GetContent().(*BlockContentOfFile); ok {
		return x.File
	}
	return nil
}

func (m *Block) GetLayout() *BlockContentLayout {
	if x, ok := m.GetContent().(*BlockContentOfLayout); ok {
		return x.Layout
	}
	return nil
}

func (m *Block) GetDiv() *BlockContentDiv {
	if x, ok := m.GetContent().(*BlockContentOfDiv); ok {
		return x.Div
	}
	return nil
}

func (m *Block) GetBookmark() *BlockContentBookmark {
	if x, ok := m.GetContent().(*BlockContentOfBookmark); ok {
		return x.Bookmark
	}
	return nil
}

func (m *Block) GetIcon() *BlockContentIcon {
	if x, ok := m.GetContent().(*BlockContentOfIcon); ok {
		return x.Icon
	}
	return nil
}

func (m *Block) GetLink() *BlockContentLink {
	if x, ok := m.GetContent().(*BlockContentOfLink); ok {
		return x.Link
	}
	return nil
}

func (m *Block) GetDataview() *BlockContentDataview {
	if x, ok := m.GetContent().(*BlockContentOfDataview); ok {
		return x.Dataview
	}
	return nil
}

func (m *Block) GetRelation() *BlockContentRelation {
	if x, ok := m.GetContent().(*BlockContentOfRelation); ok {
		return x.Relation
	}
	return nil
}

func (m *Block) GetFeaturedRelations() *BlockContentFeaturedRelations {
	if x, ok := m.GetContent().(*BlockContentOfFeaturedRelations); ok {
		return x.FeaturedRelations
	}
	return nil
}

func (m *Block) GetLatex() *BlockContentLatex {
	if x, ok := m.GetContent().(*BlockContentOfLatex); ok {
		return x.Latex
	}
	return nil
}

func (m *Block) GetTableOfContents() *BlockContentTableOfContents {
	if x, ok := m.GetContent().(*BlockContentOfTableOfContents); ok {
		return x.TableOfContents
	}
	return nil
}

func (m *Block) GetTable() *BlockContentTable {
	if x, ok := m.GetContent().(*BlockContentOfTable); ok {
		return x.Table
	}
	return nil
}

func (m *Block) GetTableColumn() *BlockContentTableColumn {
	if x, ok := m.GetContent().(*BlockContentOfTableColumn); ok {
		return x.TableColumn
	}
	return nil
}

func (m *Block) GetTableRow() *BlockContentTableRow {
	if x, ok := m.GetContent().(*BlockContentOfTableRow); ok {
		return x.TableRow
	}
	return nil
}

func (m *Block) GetWidget() *BlockContentWidget {
	if x, ok := m.GetContent().(*BlockContentOfWidget); ok {
		return x.Widget
	}
	return nil
}

func (m *Block) GetChat() *BlockContentChat {
	if x, ok := m.GetContent().(*BlockContentOfChat); ok {
		return x.Chat
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Block) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BlockContentOfSmartblock)(nil),
		(*BlockContentOfText)(nil),
		(*BlockContentOfFile)(nil),
		(*BlockContentOfLayout)(nil),
		(*BlockContentOfDiv)(nil),
		(*BlockContentOfBookmark)(nil),
		(*BlockContentOfIcon)(nil),
		(*BlockContentOfLink)(nil),
		(*BlockContentOfDataview)(nil),
		(*BlockContentOfRelation)(nil),
		(*BlockContentOfFeaturedRelations)(nil),
		(*BlockContentOfLatex)(nil),
		(*BlockContentOfTableOfContents)(nil),
		(*BlockContentOfTable)(nil),
		(*BlockContentOfTableColumn)(nil),
		(*BlockContentOfTableRow)(nil),
		(*BlockContentOfWidget)(nil),
		(*BlockContentOfChat)(nil),
	}
}

type BlockRestrictions struct {
	Read   bool `protobuf:"varint,1,opt,name=read,proto3" json:"read,omitempty"`
	Edit   bool `protobuf:"varint,2,opt,name=edit,proto3" json:"edit,omitempty"`
	Remove bool `protobuf:"varint,3,opt,name=remove,proto3" json:"remove,omitempty"`
	Drag   bool `protobuf:"varint,4,opt,name=drag,proto3" json:"drag,omitempty"`
	DropOn bool `protobuf:"varint,5,opt,name=dropOn,proto3" json:"dropOn,omitempty"`
}

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

var xxx_messageInfo_BlockRestrictions proto.InternalMessageInfo

func (m *BlockRestrictions) GetRead() bool {
	if m != nil {
		return m.Read
	}
	return false
}

func (m *BlockRestrictions) GetEdit() bool {
	if m != nil {
		return m.Edit
	}
	return false
}

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

func (m *BlockRestrictions) GetDrag() bool {
	if m != nil {
		return m.Drag
	}
	return false
}

func (m *BlockRestrictions) GetDropOn() bool {
	if m != nil {
		return m.DropOn
	}
	return false
}

type BlockContent struct {
}

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

var xxx_messageInfo_BlockContent proto.InternalMessageInfo

// Layout have no visual representation, but affects on blocks, that it contains.
// Row/Column layout blocks creates only automatically, after some of a D&D operations, for example
type BlockContentLayout struct {
	Style BlockContentLayoutStyle `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.model.BlockContentLayoutStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_BlockContentLayout proto.InternalMessageInfo

func (m *BlockContentLayout) GetStyle() BlockContentLayoutStyle {
	if m != nil {
		return m.Style
	}
	return BlockContentLayout_Row
}

// Link: block to link some content from an external sources.
type BlockContentLink struct {
	TargetBlockId string                      `protobuf:"bytes,1,opt,name=targetBlockId,proto3" json:"targetBlockId,omitempty"`
	Style         BlockContentLinkStyle       `protobuf:"varint,2,opt,name=style,proto3,enum=anytype.model.BlockContentLinkStyle" json:"style,omitempty"`
	Fields        *types.Struct               `protobuf:"bytes,3,opt,name=fields,proto3" json:"fields,omitempty"`
	IconSize      BlockContentLinkIconSize    `protobuf:"varint,4,opt,name=iconSize,proto3,enum=anytype.model.BlockContentLinkIconSize" json:"iconSize,omitempty"`
	CardStyle     BlockContentLinkCardStyle   `protobuf:"varint,5,opt,name=cardStyle,proto3,enum=anytype.model.BlockContentLinkCardStyle" json:"cardStyle,omitempty"`
	Description   BlockContentLinkDescription `protobuf:"varint,6,opt,name=description,proto3,enum=anytype.model.BlockContentLinkDescription" json:"description,omitempty"`
	Relations     []string                    `protobuf:"bytes,7,rep,name=relations,proto3" json:"relations,omitempty"`
}

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

var xxx_messageInfo_BlockContentLink proto.InternalMessageInfo

func (m *BlockContentLink) GetTargetBlockId() string {
	if m != nil {
		return m.TargetBlockId
	}
	return ""
}

func (m *BlockContentLink) GetStyle() BlockContentLinkStyle {
	if m != nil {
		return m.Style
	}
	return BlockContentLink_Page
}

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

func (m *BlockContentLink) GetIconSize() BlockContentLinkIconSize {
	if m != nil {
		return m.IconSize
	}
	return BlockContentLink_SizeNone
}

func (m *BlockContentLink) GetCardStyle() BlockContentLinkCardStyle {
	if m != nil {
		return m.CardStyle
	}
	return BlockContentLink_Text
}

func (m *BlockContentLink) GetDescription() BlockContentLinkDescription {
	if m != nil {
		return m.Description
	}
	return BlockContentLink_None
}

func (m *BlockContentLink) GetRelations() []string {
	if m != nil {
		return m.Relations
	}
	return nil
}

// Divider: block, that contains only one horizontal thin line
type BlockContentDiv struct {
	Style BlockContentDivStyle `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.model.BlockContentDivStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_BlockContentDiv proto.InternalMessageInfo

func (m *BlockContentDiv) GetStyle() BlockContentDivStyle {
	if m != nil {
		return m.Style
	}
	return BlockContentDiv_Line
}

// Bookmark is to keep a web-link and to preview a content.
type BlockContentBookmark struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// Deprecated. Get this data from the target object.
	Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	// Deprecated. Get this data from the target object.
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Deprecated. Get this data from the target object.
	ImageHash string `protobuf:"bytes,4,opt,name=imageHash,proto3" json:"imageHash,omitempty"`
	// Deprecated. Get this data from the target object.
	FaviconHash    string                    `protobuf:"bytes,5,opt,name=faviconHash,proto3" json:"faviconHash,omitempty"`
	Type           LinkPreviewType           `protobuf:"varint,6,opt,name=type,proto3,enum=anytype.model.LinkPreviewType" json:"type,omitempty"`
	TargetObjectId string                    `protobuf:"bytes,7,opt,name=targetObjectId,proto3" json:"targetObjectId,omitempty"`
	State          BlockContentBookmarkState `protobuf:"varint,8,opt,name=state,proto3,enum=anytype.model.BlockContentBookmarkState" json:"state,omitempty"`
}

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

var xxx_messageInfo_BlockContentBookmark proto.InternalMessageInfo

func (m *BlockContentBookmark) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *BlockContentBookmark) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *BlockContentBookmark) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *BlockContentBookmark) GetImageHash() string {
	if m != nil {
		return m.ImageHash
	}
	return ""
}

func (m *BlockContentBookmark) GetFaviconHash() string {
	if m != nil {
		return m.FaviconHash
	}
	return ""
}

func (m *BlockContentBookmark) GetType() LinkPreviewType {
	if m != nil {
		return m.Type
	}
	return LinkPreview_Unknown
}

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

func (m *BlockContentBookmark) GetState() BlockContentBookmarkState {
	if m != nil {
		return m.State
	}
	return BlockContentBookmark_Empty
}

type BlockContentIcon struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_BlockContentIcon proto.InternalMessageInfo

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

type BlockContentFeaturedRelations struct {
}

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

var xxx_messageInfo_BlockContentFeaturedRelations proto.InternalMessageInfo

type BlockContentText struct {
	Text      string                 `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
	Style     BlockContentTextStyle  `protobuf:"varint,2,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle" json:"style,omitempty"`
	Marks     *BlockContentTextMarks `protobuf:"bytes,3,opt,name=marks,proto3" json:"marks,omitempty"`
	Checked   bool                   `protobuf:"varint,4,opt,name=checked,proto3" json:"checked,omitempty"`
	Color     string                 `protobuf:"bytes,5,opt,name=color,proto3" json:"color,omitempty"`
	IconEmoji string                 `protobuf:"bytes,6,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"`
	IconImage string                 `protobuf:"bytes,7,opt,name=iconImage,proto3" json:"iconImage,omitempty"`
}

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

var xxx_messageInfo_BlockContentText proto.InternalMessageInfo

func (m *BlockContentText) GetText() string {
	if m != nil {
		return m.Text
	}
	return ""
}

func (m *BlockContentText) GetStyle() BlockContentTextStyle {
	if m != nil {
		return m.Style
	}
	return BlockContentText_Paragraph
}

func (m *BlockContentText) GetMarks() *BlockContentTextMarks {
	if m != nil {
		return m.Marks
	}
	return nil
}

func (m *BlockContentText) GetChecked() bool {
	if m != nil {
		return m.Checked
	}
	return false
}

func (m *BlockContentText) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

func (m *BlockContentText) GetIconEmoji() string {
	if m != nil {
		return m.IconEmoji
	}
	return ""
}

func (m *BlockContentText) GetIconImage() string {
	if m != nil {
		return m.IconImage
	}
	return ""
}

type BlockContentTextMarks struct {
	Marks []*BlockContentTextMark `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty"`
}

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

var xxx_messageInfo_BlockContentTextMarks proto.InternalMessageInfo

func (m *BlockContentTextMarks) GetMarks() []*BlockContentTextMark {
	if m != nil {
		return m.Marks
	}
	return nil
}

type BlockContentTextMark struct {
	Range *Range                   `protobuf:"bytes,1,opt,name=range,proto3" json:"range,omitempty"`
	Type  BlockContentTextMarkType `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.model.BlockContentTextMarkType" json:"type,omitempty"`
	Param string                   `protobuf:"bytes,3,opt,name=param,proto3" json:"param,omitempty"`
}

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

var xxx_messageInfo_BlockContentTextMark proto.InternalMessageInfo

func (m *BlockContentTextMark) GetRange() *Range {
	if m != nil {
		return m.Range
	}
	return nil
}

func (m *BlockContentTextMark) GetType() BlockContentTextMarkType {
	if m != nil {
		return m.Type
	}
	return BlockContentTextMark_Strikethrough
}

func (m *BlockContentTextMark) GetParam() string {
	if m != nil {
		return m.Param
	}
	return ""
}

type BlockContentFile struct {
	Hash           string                `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Name           string                `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Type           BlockContentFileType  `protobuf:"varint,3,opt,name=type,proto3,enum=anytype.model.BlockContentFileType" json:"type,omitempty"`
	Mime           string                `protobuf:"bytes,4,opt,name=mime,proto3" json:"mime,omitempty"`
	Size_          int64                 `protobuf:"varint,5,opt,name=size,proto3" json:"size,omitempty"`
	AddedAt        int64                 `protobuf:"varint,6,opt,name=addedAt,proto3" json:"addedAt,omitempty"`
	TargetObjectId string                `protobuf:"bytes,9,opt,name=targetObjectId,proto3" json:"targetObjectId,omitempty"`
	State          BlockContentFileState `protobuf:"varint,7,opt,name=state,proto3,enum=anytype.model.BlockContentFileState" json:"state,omitempty"`
	Style          BlockContentFileStyle `protobuf:"varint,8,opt,name=style,proto3,enum=anytype.model.BlockContentFileStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_BlockContentFile proto.InternalMessageInfo

func (m *BlockContentFile) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

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

func (m *BlockContentFile) GetType() BlockContentFileType {
	if m != nil {
		return m.Type
	}
	return BlockContentFile_None
}

func (m *BlockContentFile) GetMime() string {
	if m != nil {
		return m.Mime
	}
	return ""
}

func (m *BlockContentFile) GetSize_() int64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *BlockContentFile) GetAddedAt() int64 {
	if m != nil {
		return m.AddedAt
	}
	return 0
}

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

func (m *BlockContentFile) GetState() BlockContentFileState {
	if m != nil {
		return m.State
	}
	return BlockContentFile_Empty
}

func (m *BlockContentFile) GetStyle() BlockContentFileStyle {
	if m != nil {
		return m.Style
	}
	return BlockContentFile_Auto
}

type BlockContentSmartblock struct {
}

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

var xxx_messageInfo_BlockContentSmartblock proto.InternalMessageInfo

type BlockContentDataview struct {
	Source     []string                    `protobuf:"bytes,1,rep,name=source,proto3" json:"source,omitempty"`
	Views      []*BlockContentDataviewView `protobuf:"bytes,2,rep,name=views,proto3" json:"views,omitempty"`
	ActiveView string                      `protobuf:"bytes,3,opt,name=activeView,proto3" json:"activeView,omitempty"`
	// deprecated
	Relations      []*Relation                        `protobuf:"bytes,4,rep,name=relations,proto3" json:"relations,omitempty"`
	GroupOrders    []*BlockContentDataviewGroupOrder  `protobuf:"bytes,12,rep,name=groupOrders,proto3" json:"groupOrders,omitempty"`
	ObjectOrders   []*BlockContentDataviewObjectOrder `protobuf:"bytes,13,rep,name=objectOrders,proto3" json:"objectOrders,omitempty"`
	RelationLinks  []*RelationLink                    `protobuf:"bytes,5,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
	TargetObjectId string                             `protobuf:"bytes,6,opt,name=TargetObjectId,proto3" json:"TargetObjectId,omitempty"`
	IsCollection   bool                               `protobuf:"varint,14,opt,name=isCollection,proto3" json:"isCollection,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataview proto.InternalMessageInfo

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

func (m *BlockContentDataview) GetViews() []*BlockContentDataviewView {
	if m != nil {
		return m.Views
	}
	return nil
}

func (m *BlockContentDataview) GetActiveView() string {
	if m != nil {
		return m.ActiveView
	}
	return ""
}

func (m *BlockContentDataview) GetRelations() []*Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

func (m *BlockContentDataview) GetGroupOrders() []*BlockContentDataviewGroupOrder {
	if m != nil {
		return m.GroupOrders
	}
	return nil
}

func (m *BlockContentDataview) GetObjectOrders() []*BlockContentDataviewObjectOrder {
	if m != nil {
		return m.ObjectOrders
	}
	return nil
}

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

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

func (m *BlockContentDataview) GetIsCollection() bool {
	if m != nil {
		return m.IsCollection
	}
	return false
}

type BlockContentDataviewView struct {
	Id                    string                          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type                  BlockContentDataviewViewType    `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.model.BlockContentDataviewViewType" json:"type,omitempty"`
	Name                  string                          `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Sorts                 []*BlockContentDataviewSort     `protobuf:"bytes,4,rep,name=sorts,proto3" json:"sorts,omitempty"`
	Filters               []*BlockContentDataviewFilter   `protobuf:"bytes,5,rep,name=filters,proto3" json:"filters,omitempty"`
	Relations             []*BlockContentDataviewRelation `protobuf:"bytes,6,rep,name=relations,proto3" json:"relations,omitempty"`
	CoverRelationKey      string                          `protobuf:"bytes,7,opt,name=coverRelationKey,proto3" json:"coverRelationKey,omitempty"`
	HideIcon              bool                            `protobuf:"varint,8,opt,name=hideIcon,proto3" json:"hideIcon,omitempty"`
	CardSize              BlockContentDataviewViewSize    `protobuf:"varint,9,opt,name=cardSize,proto3,enum=anytype.model.BlockContentDataviewViewSize" json:"cardSize,omitempty"`
	CoverFit              bool                            `protobuf:"varint,10,opt,name=coverFit,proto3" json:"coverFit,omitempty"`
	GroupRelationKey      string                          `protobuf:"bytes,11,opt,name=groupRelationKey,proto3" json:"groupRelationKey,omitempty"`
	GroupBackgroundColors bool                            `protobuf:"varint,12,opt,name=groupBackgroundColors,proto3" json:"groupBackgroundColors,omitempty"`
	PageLimit             int32                           `protobuf:"varint,13,opt,name=pageLimit,proto3" json:"pageLimit,omitempty"`
	DefaultTemplateId     string                          `protobuf:"bytes,14,opt,name=defaultTemplateId,proto3" json:"defaultTemplateId,omitempty"`
	DefaultObjectTypeId   string                          `protobuf:"bytes,15,opt,name=defaultObjectTypeId,proto3" json:"defaultObjectTypeId,omitempty"`
	EndRelationKey        string                          `protobuf:"bytes,16,opt,name=endRelationKey,proto3" json:"endRelationKey,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewView proto.InternalMessageInfo

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

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

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

func (m *BlockContentDataviewView) GetSorts() []*BlockContentDataviewSort {
	if m != nil {
		return m.Sorts
	}
	return nil
}

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

func (m *BlockContentDataviewView) GetRelations() []*BlockContentDataviewRelation {
	if m != nil {
		return m.Relations
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

type BlockContentDataviewRelation struct {
	Key       string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	IsVisible bool   `protobuf:"varint,2,opt,name=isVisible,proto3" json:"isVisible,omitempty"`
	Width     int32  `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"`
	// bool isReadOnly = 4; // deprecated
	DateIncludeTime bool                                    `protobuf:"varint,5,opt,name=dateIncludeTime,proto3" json:"dateIncludeTime,omitempty"`
	TimeFormat      BlockContentDataviewRelationTimeFormat  `protobuf:"varint,6,opt,name=timeFormat,proto3,enum=anytype.model.BlockContentDataviewRelationTimeFormat" json:"timeFormat,omitempty"`
	DateFormat      BlockContentDataviewRelationDateFormat  `protobuf:"varint,7,opt,name=dateFormat,proto3,enum=anytype.model.BlockContentDataviewRelationDateFormat" json:"dateFormat,omitempty"`
	Formula         BlockContentDataviewRelationFormulaType `protobuf:"varint,8,opt,name=formula,proto3,enum=anytype.model.BlockContentDataviewRelationFormulaType" json:"formula,omitempty"`
	Align           BlockAlign                              `protobuf:"varint,9,opt,name=align,proto3,enum=anytype.model.BlockAlign" json:"align,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewRelation proto.InternalMessageInfo

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

func (m *BlockContentDataviewRelation) GetIsVisible() bool {
	if m != nil {
		return m.IsVisible
	}
	return false
}

func (m *BlockContentDataviewRelation) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *BlockContentDataviewRelation) GetDateIncludeTime() bool {
	if m != nil {
		return m.DateIncludeTime
	}
	return false
}

func (m *BlockContentDataviewRelation) GetTimeFormat() BlockContentDataviewRelationTimeFormat {
	if m != nil {
		return m.TimeFormat
	}
	return BlockContentDataviewRelation_Format12
}

func (m *BlockContentDataviewRelation) GetDateFormat() BlockContentDataviewRelationDateFormat {
	if m != nil {
		return m.DateFormat
	}
	return BlockContentDataviewRelation_MonthAbbrBeforeDay
}

func (m *BlockContentDataviewRelation) GetFormula() BlockContentDataviewRelationFormulaType {
	if m != nil {
		return m.Formula
	}
	return BlockContentDataviewRelation_None
}

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

type BlockContentDataviewSort struct {
	RelationKey    string                            `protobuf:"bytes,1,opt,name=RelationKey,proto3" json:"RelationKey,omitempty"`
	Type           BlockContentDataviewSortType      `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.model.BlockContentDataviewSortType" json:"type,omitempty"`
	CustomOrder    []*types.Value                    `protobuf:"bytes,3,rep,name=customOrder,proto3" json:"customOrder,omitempty"`
	Format         RelationFormat                    `protobuf:"varint,4,opt,name=format,proto3,enum=anytype.model.RelationFormat" json:"format,omitempty"`
	IncludeTime    bool                              `protobuf:"varint,5,opt,name=includeTime,proto3" json:"includeTime,omitempty"`
	Id             string                            `protobuf:"bytes,6,opt,name=id,proto3" json:"id,omitempty"`
	EmptyPlacement BlockContentDataviewSortEmptyType `protobuf:"varint,7,opt,name=emptyPlacement,proto3,enum=anytype.model.BlockContentDataviewSortEmptyType" json:"emptyPlacement,omitempty"`
	NoCollate      bool                              `protobuf:"varint,8,opt,name=noCollate,proto3" json:"noCollate,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewSort proto.InternalMessageInfo

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

func (m *BlockContentDataviewSort) GetType() BlockContentDataviewSortType {
	if m != nil {
		return m.Type
	}
	return BlockContentDataviewSort_Asc
}

func (m *BlockContentDataviewSort) GetCustomOrder() []*types.Value {
	if m != nil {
		return m.CustomOrder
	}
	return nil
}

func (m *BlockContentDataviewSort) GetFormat() RelationFormat {
	if m != nil {
		return m.Format
	}
	return RelationFormat_longtext
}

func (m *BlockContentDataviewSort) GetIncludeTime() bool {
	if m != nil {
		return m.IncludeTime
	}
	return false
}

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

func (m *BlockContentDataviewSort) GetEmptyPlacement() BlockContentDataviewSortEmptyType {
	if m != nil {
		return m.EmptyPlacement
	}
	return BlockContentDataviewSort_NotSpecified
}

func (m *BlockContentDataviewSort) GetNoCollate() bool {
	if m != nil {
		return m.NoCollate
	}
	return false
}

type BlockContentDataviewFilter struct {
	Id               string                                `protobuf:"bytes,9,opt,name=id,proto3" json:"id,omitempty"`
	Operator         BlockContentDataviewFilterOperator    `protobuf:"varint,1,opt,name=operator,proto3,enum=anytype.model.BlockContentDataviewFilterOperator" json:"operator,omitempty"`
	RelationKey      string                                `protobuf:"bytes,2,opt,name=RelationKey,proto3" json:"RelationKey,omitempty"`
	RelationProperty string                                `protobuf:"bytes,5,opt,name=relationProperty,proto3" json:"relationProperty,omitempty"`
	Condition        BlockContentDataviewFilterCondition   `protobuf:"varint,3,opt,name=condition,proto3,enum=anytype.model.BlockContentDataviewFilterCondition" json:"condition,omitempty"`
	Value            *types.Value                          `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	QuickOption      BlockContentDataviewFilterQuickOption `protobuf:"varint,6,opt,name=quickOption,proto3,enum=anytype.model.BlockContentDataviewFilterQuickOption" json:"quickOption,omitempty"`
	Format           RelationFormat                        `protobuf:"varint,7,opt,name=format,proto3,enum=anytype.model.RelationFormat" json:"format,omitempty"`
	IncludeTime      bool                                  `protobuf:"varint,8,opt,name=includeTime,proto3" json:"includeTime,omitempty"`
	NestedFilters    []*BlockContentDataviewFilter         `protobuf:"bytes,10,rep,name=nestedFilters,proto3" json:"nestedFilters,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewFilter proto.InternalMessageInfo

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

func (m *BlockContentDataviewFilter) GetOperator() BlockContentDataviewFilterOperator {
	if m != nil {
		return m.Operator
	}
	return BlockContentDataviewFilter_No
}

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

func (m *BlockContentDataviewFilter) GetRelationProperty() string {
	if m != nil {
		return m.RelationProperty
	}
	return ""
}

func (m *BlockContentDataviewFilter) GetCondition() BlockContentDataviewFilterCondition {
	if m != nil {
		return m.Condition
	}
	return BlockContentDataviewFilter_None
}

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

func (m *BlockContentDataviewFilter) GetQuickOption() BlockContentDataviewFilterQuickOption {
	if m != nil {
		return m.QuickOption
	}
	return BlockContentDataviewFilter_ExactDate
}

func (m *BlockContentDataviewFilter) GetFormat() RelationFormat {
	if m != nil {
		return m.Format
	}
	return RelationFormat_longtext
}

func (m *BlockContentDataviewFilter) GetIncludeTime() bool {
	if m != nil {
		return m.IncludeTime
	}
	return false
}

func (m *BlockContentDataviewFilter) GetNestedFilters() []*BlockContentDataviewFilter {
	if m != nil {
		return m.NestedFilters
	}
	return nil
}

type BlockContentDataviewGroupOrder struct {
	ViewId     string                           `protobuf:"bytes,1,opt,name=viewId,proto3" json:"viewId,omitempty"`
	ViewGroups []*BlockContentDataviewViewGroup `protobuf:"bytes,2,rep,name=viewGroups,proto3" json:"viewGroups,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewGroupOrder proto.InternalMessageInfo

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

func (m *BlockContentDataviewGroupOrder) GetViewGroups() []*BlockContentDataviewViewGroup {
	if m != nil {
		return m.ViewGroups
	}
	return nil
}

type BlockContentDataviewViewGroup struct {
	GroupId         string `protobuf:"bytes,1,opt,name=groupId,proto3" json:"groupId,omitempty"`
	Index           int32  `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Hidden          bool   `protobuf:"varint,3,opt,name=hidden,proto3" json:"hidden,omitempty"`
	BackgroundColor string `protobuf:"bytes,4,opt,name=backgroundColor,proto3" json:"backgroundColor,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewViewGroup proto.InternalMessageInfo

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

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

func (m *BlockContentDataviewViewGroup) GetHidden() bool {
	if m != nil {
		return m.Hidden
	}
	return false
}

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

type BlockContentDataviewObjectOrder struct {
	ViewId    string   `protobuf:"bytes,1,opt,name=viewId,proto3" json:"viewId,omitempty"`
	GroupId   string   `protobuf:"bytes,2,opt,name=groupId,proto3" json:"groupId,omitempty"`
	ObjectIds []string `protobuf:"bytes,3,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewObjectOrder proto.InternalMessageInfo

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

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

func (m *BlockContentDataviewObjectOrder) GetObjectIds() []string {
	if m != nil {
		return m.ObjectIds
	}
	return nil
}

type BlockContentDataviewGroup struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Types that are valid to be assigned to Value:
	//
	//	*BlockContentDataviewGroupValueOfStatus
	//	*BlockContentDataviewGroupValueOfTag
	//	*BlockContentDataviewGroupValueOfCheckbox
	//	*BlockContentDataviewGroupValueOfDate
	Value IsBlockContentDataviewGroupValue `protobuf_oneof:"Value"`
}

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

var xxx_messageInfo_BlockContentDataviewGroup proto.InternalMessageInfo

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

type BlockContentDataviewGroupValueOfStatus struct {
	Status *BlockContentDataviewStatus `protobuf:"bytes,2,opt,name=status,proto3,oneof" json:"status,omitempty"`
}
type BlockContentDataviewGroupValueOfTag struct {
	Tag *BlockContentDataviewTag `protobuf:"bytes,3,opt,name=tag,proto3,oneof" json:"tag,omitempty"`
}
type BlockContentDataviewGroupValueOfCheckbox struct {
	Checkbox *BlockContentDataviewCheckbox `protobuf:"bytes,4,opt,name=checkbox,proto3,oneof" json:"checkbox,omitempty"`
}
type BlockContentDataviewGroupValueOfDate struct {
	Date *BlockContentDataviewDate `protobuf:"bytes,5,opt,name=date,proto3,oneof" json:"date,omitempty"`
}

func (*BlockContentDataviewGroupValueOfStatus) IsBlockContentDataviewGroupValue()   {}
func (*BlockContentDataviewGroupValueOfTag) IsBlockContentDataviewGroupValue()      {}
func (*BlockContentDataviewGroupValueOfCheckbox) IsBlockContentDataviewGroupValue() {}
func (*BlockContentDataviewGroupValueOfDate) IsBlockContentDataviewGroupValue()     {}

func (m *BlockContentDataviewGroup) GetValue() IsBlockContentDataviewGroupValue {
	if m != nil {
		return m.Value
	}
	return nil
}

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

func (m *BlockContentDataviewGroup) GetStatus() *BlockContentDataviewStatus {
	if x, ok := m.GetValue().(*BlockContentDataviewGroupValueOfStatus); ok {
		return x.Status
	}
	return nil
}

func (m *BlockContentDataviewGroup) GetTag() *BlockContentDataviewTag {
	if x, ok := m.GetValue().(*BlockContentDataviewGroupValueOfTag); ok {
		return x.Tag
	}
	return nil
}

func (m *BlockContentDataviewGroup) GetCheckbox() *BlockContentDataviewCheckbox {
	if x, ok := m.GetValue().(*BlockContentDataviewGroupValueOfCheckbox); ok {
		return x.Checkbox
	}
	return nil
}

func (m *BlockContentDataviewGroup) GetDate() *BlockContentDataviewDate {
	if x, ok := m.GetValue().(*BlockContentDataviewGroupValueOfDate); ok {
		return x.Date
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BlockContentDataviewGroup) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BlockContentDataviewGroupValueOfStatus)(nil),
		(*BlockContentDataviewGroupValueOfTag)(nil),
		(*BlockContentDataviewGroupValueOfCheckbox)(nil),
		(*BlockContentDataviewGroupValueOfDate)(nil),
	}
}

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

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

var xxx_messageInfo_BlockContentDataviewStatus proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_BlockContentDataviewTag proto.InternalMessageInfo

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

type BlockContentDataviewCheckbox struct {
	Checked bool `protobuf:"varint,1,opt,name=checked,proto3" json:"checked,omitempty"`
}

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

var xxx_messageInfo_BlockContentDataviewCheckbox proto.InternalMessageInfo

func (m *BlockContentDataviewCheckbox) GetChecked() bool {
	if m != nil {
		return m.Checked
	}
	return false
}

type BlockContentDataviewDate struct {
}

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

var xxx_messageInfo_BlockContentDataviewDate proto.InternalMessageInfo

type BlockContentRelation struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_BlockContentRelation proto.InternalMessageInfo

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

type BlockContentLatex struct {
	Text      string                     `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
	Processor BlockContentLatexProcessor `protobuf:"varint,2,opt,name=processor,proto3,enum=anytype.model.BlockContentLatexProcessor" json:"processor,omitempty"`
}

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

var xxx_messageInfo_BlockContentLatex proto.InternalMessageInfo

func (m *BlockContentLatex) GetText() string {
	if m != nil {
		return m.Text
	}
	return ""
}

func (m *BlockContentLatex) GetProcessor() BlockContentLatexProcessor {
	if m != nil {
		return m.Processor
	}
	return BlockContentLatex_Latex
}

type BlockContentTableOfContents struct {
}

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

var xxx_messageInfo_BlockContentTableOfContents proto.InternalMessageInfo

type BlockContentTable struct {
}

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

var xxx_messageInfo_BlockContentTable proto.InternalMessageInfo

type BlockContentTableColumn struct {
}

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

var xxx_messageInfo_BlockContentTableColumn proto.InternalMessageInfo

type BlockContentTableRow struct {
	IsHeader bool `protobuf:"varint,1,opt,name=isHeader,proto3" json:"isHeader,omitempty"`
}

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

var xxx_messageInfo_BlockContentTableRow proto.InternalMessageInfo

func (m *BlockContentTableRow) GetIsHeader() bool {
	if m != nil {
		return m.IsHeader
	}
	return false
}

type BlockContentWidget struct {
	Layout    BlockContentWidgetLayout `protobuf:"varint,1,opt,name=layout,proto3,enum=anytype.model.BlockContentWidgetLayout" json:"layout,omitempty"`
	Limit     int32                    `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	ViewId    string                   `protobuf:"bytes,3,opt,name=viewId,proto3" json:"viewId,omitempty"`
	AutoAdded bool                     `protobuf:"varint,4,opt,name=autoAdded,proto3" json:"autoAdded,omitempty"`
}

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

var xxx_messageInfo_BlockContentWidget proto.InternalMessageInfo

func (m *BlockContentWidget) GetLayout() BlockContentWidgetLayout {
	if m != nil {
		return m.Layout
	}
	return BlockContentWidget_Link
}

func (m *BlockContentWidget) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

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

func (m *BlockContentWidget) GetAutoAdded() bool {
	if m != nil {
		return m.AutoAdded
	}
	return false
}

type BlockContentChat struct {
}

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

var xxx_messageInfo_BlockContentChat proto.InternalMessageInfo

// Used to decode block meta only, without the content itself
type BlockMetaOnly 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 *BlockMetaOnly) Reset()         { *m = BlockMetaOnly{} }
func (m *BlockMetaOnly) String() string { return proto.CompactTextString(m) }
func (*BlockMetaOnly) ProtoMessage()    {}
func (*BlockMetaOnly) Descriptor() ([]byte, []int) {
	return fileDescriptor_98a910b73321e591, []int{3}
}
func (m *BlockMetaOnly) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockMetaOnly) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockMetaOnly.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 *BlockMetaOnly) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockMetaOnly.Merge(m, src)
}
func (m *BlockMetaOnly) XXX_Size() int {
	return m.Size()
}
func (m *BlockMetaOnly) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockMetaOnly.DiscardUnknown(m)
}

var xxx_messageInfo_BlockMetaOnly proto.InternalMessageInfo

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

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

// General purpose structure, uses in Mark.
type Range struct {
	From int32 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"`
	To   int32 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
}

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

var xxx_messageInfo_Range proto.InternalMessageInfo

func (m *Range) GetFrom() int32 {
	if m != nil {
		return m.From
	}
	return 0
}

func (m *Range) GetTo() int32 {
	if m != nil {
		return m.To
	}
	return 0
}

// *
// Contains basic information about a user account
type Account struct {
	Id     string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Config *AccountConfig `protobuf:"bytes,4,opt,name=config,proto3" json:"config,omitempty"`
	Status *AccountStatus `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	Info   *AccountInfo   `protobuf:"bytes,6,opt,name=info,proto3" json:"info,omitempty"`
}

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

var xxx_messageInfo_Account proto.InternalMessageInfo

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

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

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

func (m *Account) GetInfo() *AccountInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

type AccountConfig struct {
	EnableDataview          bool          `protobuf:"varint,1,opt,name=enableDataview,proto3" json:"enableDataview,omitempty"`
	EnableDebug             bool          `protobuf:"varint,2,opt,name=enableDebug,proto3" json:"enableDebug,omitempty"`
	EnablePrereleaseChannel bool          `protobuf:"varint,3,opt,name=enablePrereleaseChannel,proto3" json:"enablePrereleaseChannel,omitempty"`
	EnableSpaces            bool          `protobuf:"varint,4,opt,name=enableSpaces,proto3" json:"enableSpaces,omitempty"`
	Extra                   *types.Struct `protobuf:"bytes,100,opt,name=extra,proto3" json:"extra,omitempty"`
}

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

var xxx_messageInfo_AccountConfig proto.InternalMessageInfo

func (m *AccountConfig) GetEnableDataview() bool {
	if m != nil {
		return m.EnableDataview
	}
	return false
}

func (m *AccountConfig) GetEnableDebug() bool {
	if m != nil {
		return m.EnableDebug
	}
	return false
}

func (m *AccountConfig) GetEnablePrereleaseChannel() bool {
	if m != nil {
		return m.EnablePrereleaseChannel
	}
	return false
}

func (m *AccountConfig) GetEnableSpaces() bool {
	if m != nil {
		return m.EnableSpaces
	}
	return false
}

func (m *AccountConfig) GetExtra() *types.Struct {
	if m != nil {
		return m.Extra
	}
	return nil
}

type AccountStatus struct {
	StatusType   AccountStatusType `protobuf:"varint,1,opt,name=statusType,proto3,enum=anytype.model.AccountStatusType" json:"statusType,omitempty"`
	DeletionDate int64             `protobuf:"varint,2,opt,name=deletionDate,proto3" json:"deletionDate,omitempty"`
}

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

var xxx_messageInfo_AccountStatus proto.InternalMessageInfo

func (m *AccountStatus) GetStatusType() AccountStatusType {
	if m != nil {
		return m.StatusType
	}
	return Account_Active
}

func (m *AccountStatus) GetDeletionDate() int64 {
	if m != nil {
		return m.DeletionDate
	}
	return 0
}

type AccountInfo struct {
	HomeObjectId           string `protobuf:"bytes,2,opt,name=homeObjectId,proto3" json:"homeObjectId,omitempty"`
	ArchiveObjectId        string `protobuf:"bytes,3,opt,name=archiveObjectId,proto3" json:"archiveObjectId,omitempty"`
	ProfileObjectId        string `protobuf:"bytes,4,opt,name=profileObjectId,proto3" json:"profileObjectId,omitempty"`
	MarketplaceWorkspaceId string `protobuf:"bytes,11,opt,name=marketplaceWorkspaceId,proto3" json:"marketplaceWorkspaceId,omitempty"`
	WorkspaceObjectId      string `protobuf:"bytes,15,opt,name=workspaceObjectId,proto3" json:"workspaceObjectId,omitempty"`
	SpaceChatId            string `protobuf:"bytes,16,opt,name=spaceChatId,proto3" json:"spaceChatId,omitempty"`
	DeviceId               string `protobuf:"bytes,8,opt,name=deviceId,proto3" json:"deviceId,omitempty"`
	AccountSpaceId         string `protobuf:"bytes,9,opt,name=accountSpaceId,proto3" json:"accountSpaceId,omitempty"`
	WidgetsId              string `protobuf:"bytes,10,opt,name=widgetsId,proto3" json:"widgetsId,omitempty"`
	SpaceViewId            string `protobuf:"bytes,13,opt,name=spaceViewId,proto3" json:"spaceViewId,omitempty"`
	TechSpaceId            string `protobuf:"bytes,14,opt,name=techSpaceId,proto3" json:"techSpaceId,omitempty"`
	GatewayUrl             string `protobuf:"bytes,101,opt,name=gatewayUrl,proto3" json:"gatewayUrl,omitempty"`
	LocalStoragePath       string `protobuf:"bytes,103,opt,name=localStoragePath,proto3" json:"localStoragePath,omitempty"`
	TimeZone               string `protobuf:"bytes,104,opt,name=timeZone,proto3" json:"timeZone,omitempty"`
	AnalyticsId            string `protobuf:"bytes,105,opt,name=analyticsId,proto3" json:"analyticsId,omitempty"`
	NetworkId              string `protobuf:"bytes,106,opt,name=networkId,proto3" json:"networkId,omitempty"`
	EthereumAddress        string `protobuf:"bytes,107,opt,name=ethereumAddress,proto3" json:"ethereumAddress,omitempty"`
}

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

var xxx_messageInfo_AccountInfo proto.InternalMessageInfo

func (m *AccountInfo) GetHomeObjectId() string {
	if m != nil {
		return m.HomeObjectId
	}
	return ""
}

func (m *AccountInfo) GetArchiveObjectId() string {
	if m != nil {
		return m.ArchiveObjectId
	}
	return ""
}

func (m *AccountInfo) GetProfileObjectId() string {
	if m != nil {
		return m.ProfileObjectId
	}
	return ""
}

func (m *AccountInfo) GetMarketplaceWorkspaceId() string {
	if m != nil {
		return m.MarketplaceWorkspaceId
	}
	return ""
}

func (m *AccountInfo) GetWorkspaceObjectId() string {
	if m != nil {
		return m.WorkspaceObjectId
	}
	return ""
}

func (m *AccountInfo) GetSpaceChatId() string {
	if m != nil {
		return m.SpaceChatId
	}
	return ""
}

func (m *AccountInfo) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *AccountInfo) GetAccountSpaceId() string {
	if m != nil {
		return m.AccountSpaceId
	}
	return ""
}

func (m *AccountInfo) GetWidgetsId() string {
	if m != nil {
		return m.WidgetsId
	}
	return ""
}

func (m *AccountInfo) GetSpaceViewId() string {
	if m != nil {
		return m.SpaceViewId
	}
	return ""
}

func (m *AccountInfo) GetTechSpaceId() string {
	if m != nil {
		return m.TechSpaceId
	}
	return ""
}

func (m *AccountInfo) GetGatewayUrl() string {
	if m != nil {
		return m.GatewayUrl
	}
	return ""
}

func (m *AccountInfo) GetLocalStoragePath() string {
	if m != nil {
		return m.LocalStoragePath
	}
	return ""
}

func (m *AccountInfo) GetTimeZone() string {
	if m != nil {
		return m.TimeZone
	}
	return ""
}

func (m *AccountInfo) GetAnalyticsId() string {
	if m != nil {
		return m.AnalyticsId
	}
	return ""
}

func (m *AccountInfo) GetNetworkId() string {
	if m != nil {
		return m.NetworkId
	}
	return ""
}

func (m *AccountInfo) GetEthereumAddress() string {
	if m != nil {
		return m.EthereumAddress
	}
	return ""
}

type AccountAuth struct {
}

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

var xxx_messageInfo_AccountAuth proto.InternalMessageInfo

type AccountAuthAppInfo struct {
	AppHash   string                   `protobuf:"bytes,1,opt,name=appHash,proto3" json:"appHash,omitempty"`
	AppName   string                   `protobuf:"bytes,2,opt,name=appName,proto3" json:"appName,omitempty"`
	AppKey    string                   `protobuf:"bytes,4,opt,name=appKey,proto3" json:"appKey,omitempty"`
	CreatedAt int64                    `protobuf:"varint,5,opt,name=createdAt,proto3" json:"createdAt,omitempty"`
	ExpireAt  int64                    `protobuf:"varint,6,opt,name=expireAt,proto3" json:"expireAt,omitempty"`
	Scope     AccountAuthLocalApiScope `protobuf:"varint,7,opt,name=scope,proto3,enum=anytype.model.AccountAuthLocalApiScope" json:"scope,omitempty"`
	IsActive  bool                     `protobuf:"varint,8,opt,name=isActive,proto3" json:"isActive,omitempty"`
}

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

var xxx_messageInfo_AccountAuthAppInfo proto.InternalMessageInfo

func (m *AccountAuthAppInfo) GetAppHash() string {
	if m != nil {
		return m.AppHash
	}
	return ""
}

func (m *AccountAuthAppInfo) GetAppName() string {
	if m != nil {
		return m.AppName
	}
	return ""
}

func (m *AccountAuthAppInfo) GetAppKey() string {
	if m != nil {
		return m.AppKey
	}
	return ""
}

func (m *AccountAuthAppInfo) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *AccountAuthAppInfo) GetExpireAt() int64 {
	if m != nil {
		return m.ExpireAt
	}
	return 0
}

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

func (m *AccountAuthAppInfo) GetIsActive() bool {
	if m != nil {
		return m.IsActive
	}
	return false
}

type LinkPreview struct {
	Url         string          `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Title       string          `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Description string          `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	ImageUrl    string          `protobuf:"bytes,4,opt,name=imageUrl,proto3" json:"imageUrl,omitempty"`
	FaviconUrl  string          `protobuf:"bytes,5,opt,name=faviconUrl,proto3" json:"faviconUrl,omitempty"`
	Type        LinkPreviewType `protobuf:"varint,6,opt,name=type,proto3,enum=anytype.model.LinkPreviewType" json:"type,omitempty"`
}

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

var xxx_messageInfo_LinkPreview proto.InternalMessageInfo

func (m *LinkPreview) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *LinkPreview) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *LinkPreview) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *LinkPreview) GetImageUrl() string {
	if m != nil {
		return m.ImageUrl
	}
	return ""
}

func (m *LinkPreview) GetFaviconUrl() string {
	if m != nil {
		return m.FaviconUrl
	}
	return ""
}

func (m *LinkPreview) GetType() LinkPreviewType {
	if m != nil {
		return m.Type
	}
	return LinkPreview_Unknown
}

type Restrictions struct {
	Object   []RestrictionsObjectRestriction     `protobuf:"varint,1,rep,packed,name=object,proto3,enum=anytype.model.RestrictionsObjectRestriction" json:"object,omitempty"`
	Dataview []*RestrictionsDataviewRestrictions `protobuf:"bytes,2,rep,name=dataview,proto3" json:"dataview,omitempty"`
}

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

var xxx_messageInfo_Restrictions proto.InternalMessageInfo

func (m *Restrictions) GetObject() []RestrictionsObjectRestriction {
	if m != nil {
		return m.Object
	}
	return nil
}

func (m *Restrictions) GetDataview() []*RestrictionsDataviewRestrictions {
	if m != nil {
		return m.Dataview
	}
	return nil
}

type RestrictionsDataviewRestrictions struct {
	BlockId      string                            `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Restrictions []RestrictionsDataviewRestriction `protobuf:"varint,2,rep,packed,name=restrictions,proto3,enum=anytype.model.RestrictionsDataviewRestriction" json:"restrictions,omitempty"`
}

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

var xxx_messageInfo_RestrictionsDataviewRestrictions proto.InternalMessageInfo

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

func (m *RestrictionsDataviewRestrictions) GetRestrictions() []RestrictionsDataviewRestriction {
	if m != nil {
		return m.Restrictions
	}
	return nil
}

type Object struct {
}

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

var xxx_messageInfo_Object proto.InternalMessageInfo

type ObjectChangePayload struct {
	SmartBlockType SmartBlockType `protobuf:"varint,1,opt,name=smartBlockType,proto3,enum=anytype.model.SmartBlockType" json:"smartBlockType,omitempty"`
	Key            string         `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Data           []byte         `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_ObjectChangePayload proto.InternalMessageInfo

func (m *ObjectChangePayload) GetSmartBlockType() SmartBlockType {
	if m != nil {
		return m.SmartBlockType
	}
	return SmartBlockType_AccountOld
}

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

func (m *ObjectChangePayload) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type SpaceObjectHeader struct {
	SpaceID string `protobuf:"bytes,1,opt,name=spaceID,proto3" json:"spaceID,omitempty"`
}

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

var xxx_messageInfo_SpaceObjectHeader proto.InternalMessageInfo

func (m *SpaceObjectHeader) GetSpaceID() string {
	if m != nil {
		return m.SpaceID
	}
	return ""
}

type ObjectType struct {
	Url                    string           `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Name                   string           `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	RelationLinks          []*RelationLink  `protobuf:"bytes,3,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
	Layout                 ObjectTypeLayout `protobuf:"varint,4,opt,name=layout,proto3,enum=anytype.model.ObjectTypeLayout" json:"layout,omitempty"`
	IconEmoji              string           `protobuf:"bytes,5,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"`
	Description            string           `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"`
	Hidden                 bool             `protobuf:"varint,7,opt,name=hidden,proto3" json:"hidden,omitempty"`
	Readonly               bool             `protobuf:"varint,10,opt,name=readonly,proto3" json:"readonly,omitempty"`
	Types                  []SmartBlockType `protobuf:"varint,8,rep,packed,name=types,proto3,enum=anytype.model.SmartBlockType" json:"types,omitempty"`
	IsArchived             bool             `protobuf:"varint,9,opt,name=isArchived,proto3" json:"isArchived,omitempty"`
	InstalledByDefault     bool             `protobuf:"varint,11,opt,name=installedByDefault,proto3" json:"installedByDefault,omitempty"`
	Key                    string           `protobuf:"bytes,12,opt,name=key,proto3" json:"key,omitempty"`
	Revision               int64            `protobuf:"varint,13,opt,name=revision,proto3" json:"revision,omitempty"`
	RestrictObjectCreation bool             `protobuf:"varint,14,opt,name=restrictObjectCreation,proto3" json:"restrictObjectCreation,omitempty"`
	IconColor              int64            `protobuf:"varint,15,opt,name=iconColor,proto3" json:"iconColor,omitempty"`
	IconName               string           `protobuf:"bytes,16,opt,name=iconName,proto3" json:"iconName,omitempty"`
	PluralName             string           `protobuf:"bytes,17,opt,name=pluralName,proto3" json:"pluralName,omitempty"`
}

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

var xxx_messageInfo_ObjectType proto.InternalMessageInfo

func (m *ObjectType) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

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

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

func (m *ObjectType) GetLayout() ObjectTypeLayout {
	if m != nil {
		return m.Layout
	}
	return ObjectType_basic
}

func (m *ObjectType) GetIconEmoji() string {
	if m != nil {
		return m.IconEmoji
	}
	return ""
}

func (m *ObjectType) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *ObjectType) GetHidden() bool {
	if m != nil {
		return m.Hidden
	}
	return false
}

func (m *ObjectType) GetReadonly() bool {
	if m != nil {
		return m.Readonly
	}
	return false
}

func (m *ObjectType) GetTypes() []SmartBlockType {
	if m != nil {
		return m.Types
	}
	return nil
}

func (m *ObjectType) GetIsArchived() bool {
	if m != nil {
		return m.IsArchived
	}
	return false
}

func (m *ObjectType) GetInstalledByDefault() bool {
	if m != nil {
		return m.InstalledByDefault
	}
	return false
}

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

func (m *ObjectType) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *ObjectType) GetRestrictObjectCreation() bool {
	if m != nil {
		return m.RestrictObjectCreation
	}
	return false
}

func (m *ObjectType) GetIconColor() int64 {
	if m != nil {
		return m.IconColor
	}
	return 0
}

func (m *ObjectType) GetIconName() string {
	if m != nil {
		return m.IconName
	}
	return ""
}

func (m *ObjectType) GetPluralName() string {
	if m != nil {
		return m.PluralName
	}
	return ""
}

type Layout struct {
	Id                ObjectTypeLayout `protobuf:"varint,1,opt,name=id,proto3,enum=anytype.model.ObjectTypeLayout" json:"id,omitempty"`
	Name              string           `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	RequiredRelations []*Relation      `protobuf:"bytes,3,rep,name=requiredRelations,proto3" json:"requiredRelations,omitempty"`
}

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

var xxx_messageInfo_Layout proto.InternalMessageInfo

func (m *Layout) GetId() ObjectTypeLayout {
	if m != nil {
		return m.Id
	}
	return ObjectType_basic
}

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

func (m *Layout) GetRequiredRelations() []*Relation {
	if m != nil {
		return m.RequiredRelations
	}
	return nil
}

type RelationWithValue struct {
	Relation *Relation    `protobuf:"bytes,1,opt,name=relation,proto3" json:"relation,omitempty"`
	Value    *types.Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_RelationWithValue proto.InternalMessageInfo

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

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

// Relation describe the human-interpreted relation type. It may be something like "Date of creation, format=date" or "Assignee, format=objectId, objectType=person"
type Relation struct {
	Id string `protobuf:"bytes,100,opt,name=id,proto3" json:"id,omitempty"`
	// Key under which the value is stored in the map. Must be unique for the object type.
	// It usually auto-generated bsonid, but also may be something human-readable in case of prebuilt types.
	Key              string             `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Format           RelationFormat     `protobuf:"varint,2,opt,name=format,proto3,enum=anytype.model.RelationFormat" json:"format,omitempty"`
	Name             string             `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	DefaultValue     *types.Value       `protobuf:"bytes,4,opt,name=defaultValue,proto3" json:"defaultValue,omitempty"`
	DataSource       RelationDataSource `protobuf:"varint,5,opt,name=dataSource,proto3,enum=anytype.model.RelationDataSource" json:"dataSource,omitempty"`
	Hidden           bool               `protobuf:"varint,6,opt,name=hidden,proto3" json:"hidden,omitempty"`
	ReadOnly         bool               `protobuf:"varint,7,opt,name=readOnly,proto3" json:"readOnly,omitempty"`
	ReadOnlyRelation bool               `protobuf:"varint,15,opt,name=readOnlyRelation,proto3" json:"readOnlyRelation,omitempty"`
	Multi            bool               `protobuf:"varint,8,opt,name=multi,proto3" json:"multi,omitempty"`
	ObjectTypes      []string           `protobuf:"bytes,9,rep,name=objectTypes,proto3" json:"objectTypes,omitempty"`
	// index 10, 11 was used in internal-only builds. Can be reused, but may break some test accounts
	SelectDict  []*RelationOption `protobuf:"bytes,12,rep,name=selectDict,proto3" json:"selectDict,omitempty"`
	MaxCount    int32             `protobuf:"varint,13,opt,name=maxCount,proto3" json:"maxCount,omitempty"`
	Description string            `protobuf:"bytes,14,opt,name=description,proto3" json:"description,omitempty"`
	// on-store fields, injected only locally
	Scope       RelationScope `protobuf:"varint,20,opt,name=scope,proto3,enum=anytype.model.RelationScope" json:"scope,omitempty"`
	Creator     string        `protobuf:"bytes,21,opt,name=creator,proto3" json:"creator,omitempty"`
	Revision    int64         `protobuf:"varint,22,opt,name=revision,proto3" json:"revision,omitempty"`
	IncludeTime bool          `protobuf:"varint,23,opt,name=includeTime,proto3" json:"includeTime,omitempty"`
}

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

var xxx_messageInfo_Relation proto.InternalMessageInfo

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

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

func (m *Relation) GetFormat() RelationFormat {
	if m != nil {
		return m.Format
	}
	return RelationFormat_longtext
}

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

func (m *Relation) GetDefaultValue() *types.Value {
	if m != nil {
		return m.DefaultValue
	}
	return nil
}

func (m *Relation) GetDataSource() RelationDataSource {
	if m != nil {
		return m.DataSource
	}
	return Relation_details
}

func (m *Relation) GetHidden() bool {
	if m != nil {
		return m.Hidden
	}
	return false
}

func (m *Relation) GetReadOnly() bool {
	if m != nil {
		return m.ReadOnly
	}
	return false
}

func (m *Relation) GetReadOnlyRelation() bool {
	if m != nil {
		return m.ReadOnlyRelation
	}
	return false
}

func (m *Relation) GetMulti() bool {
	if m != nil {
		return m.Multi
	}
	return false
}

func (m *Relation) GetObjectTypes() []string {
	if m != nil {
		return m.ObjectTypes
	}
	return nil
}

func (m *Relation) GetSelectDict() []*RelationOption {
	if m != nil {
		return m.SelectDict
	}
	return nil
}

func (m *Relation) GetMaxCount() int32 {
	if m != nil {
		return m.MaxCount
	}
	return 0
}

func (m *Relation) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Relation) GetScope() RelationScope {
	if m != nil {
		return m.Scope
	}
	return Relation_object
}

func (m *Relation) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *Relation) GetRevision() int64 {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *Relation) GetIncludeTime() bool {
	if m != nil {
		return m.IncludeTime
	}
	return false
}

type RelationOption struct {
	Id    string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Text  string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	Color string `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
	// 4 is reserved for old relation format
	RelationKey string `protobuf:"bytes,5,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
}

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

var xxx_messageInfo_RelationOption proto.InternalMessageInfo

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

func (m *RelationOption) GetText() string {
	if m != nil {
		return m.Text
	}
	return ""
}

func (m *RelationOption) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

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

type RelationLink struct {
	Key    string         `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Format RelationFormat `protobuf:"varint,2,opt,name=format,proto3,enum=anytype.model.RelationFormat" json:"format,omitempty"`
}

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

var xxx_messageInfo_RelationLink proto.InternalMessageInfo

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

func (m *RelationLink) GetFormat() RelationFormat {
	if m != nil {
		return m.Format
	}
	return RelationFormat_longtext
}

type Relations struct {
	Relations []*Relation `protobuf:"bytes,1,rep,name=relations,proto3" json:"relations,omitempty"`
}

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

var xxx_messageInfo_Relations proto.InternalMessageInfo

func (m *Relations) GetRelations() []*Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RelationOptions struct {
	Options []*RelationOption `protobuf:"bytes,1,rep,name=options,proto3" json:"options,omitempty"`
}

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

var xxx_messageInfo_RelationOptions proto.InternalMessageInfo

func (m *RelationOptions) GetOptions() []*RelationOption {
	if m != nil {
		return m.Options
	}
	return nil
}

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

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

var xxx_messageInfo_InternalFlag proto.InternalMessageInfo

func (m *InternalFlag) GetValue() InternalFlagValue {
	if m != nil {
		return m.Value
	}
	return InternalFlag_editorDeleteEmpty
}

// Works with a smart blocks: Page, Dashboard
// Dashboard opened, click on a page, Rpc.Block.open, Block.ShowFullscreen(PageBlock)
type ObjectView struct {
	RootId            string                        `protobuf:"bytes,1,opt,name=rootId,proto3" json:"rootId,omitempty"`
	Blocks            []*Block                      `protobuf:"bytes,2,rep,name=blocks,proto3" json:"blocks,omitempty"`
	Details           []*ObjectViewDetailsSet       `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
	Type              SmartBlockType                `protobuf:"varint,4,opt,name=type,proto3,enum=anytype.model.SmartBlockType" json:"type,omitempty"`
	Relations         []*Relation                   `protobuf:"bytes,7,rep,name=relations,proto3" json:"relations,omitempty"`
	RelationLinks     []*RelationLink               `protobuf:"bytes,10,rep,name=relationLinks,proto3" json:"relationLinks,omitempty"`
	Restrictions      *Restrictions                 `protobuf:"bytes,8,opt,name=restrictions,proto3" json:"restrictions,omitempty"`
	History           *ObjectViewHistorySize        `protobuf:"bytes,9,opt,name=history,proto3" json:"history,omitempty"`
	BlockParticipants []*ObjectViewBlockParticipant `protobuf:"bytes,11,rep,name=blockParticipants,proto3" json:"blockParticipants,omitempty"`
}

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

var xxx_messageInfo_ObjectView proto.InternalMessageInfo

func (m *ObjectView) GetRootId() string {
	if m != nil {
		return m.RootId
	}
	return ""
}

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

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

func (m *ObjectView) GetType() SmartBlockType {
	if m != nil {
		return m.Type
	}
	return SmartBlockType_AccountOld
}

func (m *ObjectView) GetRelations() []*Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

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

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

func (m *ObjectView) GetHistory() *ObjectViewHistorySize {
	if m != nil {
		return m.History
	}
	return nil
}

func (m *ObjectView) GetBlockParticipants() []*ObjectViewBlockParticipant {
	if m != nil {
		return m.BlockParticipants
	}
	return nil
}

type ObjectViewDetailsSet 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"`
	SubIds  []string      `protobuf:"bytes,3,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

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

var xxx_messageInfo_ObjectViewDetailsSet proto.InternalMessageInfo

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

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

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

type ObjectViewRelationWithValuePerObject struct {
	ObjectId  string               `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Relations []*RelationWithValue `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

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

var xxx_messageInfo_ObjectViewRelationWithValuePerObject proto.InternalMessageInfo

func (m *ObjectViewRelationWithValuePerObject) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	return ""
}

func (m *ObjectViewRelationWithValuePerObject) GetRelations() []*RelationWithValue {
	if m != nil {
		return m.Relations
	}
	return nil
}

type ObjectViewHistorySize struct {
	Undo int32 `protobuf:"varint,1,opt,name=undo,proto3" json:"undo,omitempty"`
	Redo int32 `protobuf:"varint,2,opt,name=redo,proto3" json:"redo,omitempty"`
}

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

var xxx_messageInfo_ObjectViewHistorySize proto.InternalMessageInfo

func (m *ObjectViewHistorySize) GetUndo() int32 {
	if m != nil {
		return m.Undo
	}
	return 0
}

func (m *ObjectViewHistorySize) GetRedo() int32 {
	if m != nil {
		return m.Redo
	}
	return 0
}

type ObjectViewBlockParticipant struct {
	BlockId       string `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
	ParticipantId string `protobuf:"bytes,2,opt,name=participantId,proto3" json:"participantId,omitempty"`
}

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

var xxx_messageInfo_ObjectViewBlockParticipant proto.InternalMessageInfo

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

func (m *ObjectViewBlockParticipant) GetParticipantId() string {
	if m != nil {
		return m.ParticipantId
	}
	return ""
}

type ParticipantPermissionChange struct {
	Identity string                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	Perms    ParticipantPermissions `protobuf:"varint,2,opt,name=perms,proto3,enum=anytype.model.ParticipantPermissions" json:"perms,omitempty"`
}

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

var xxx_messageInfo_ParticipantPermissionChange proto.InternalMessageInfo

func (m *ParticipantPermissionChange) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *ParticipantPermissionChange) GetPerms() ParticipantPermissions {
	if m != nil {
		return m.Perms
	}
	return ParticipantPermissions_Reader
}

type Metadata struct {
	// Types that are valid to be assigned to Payload:
	//
	//	*MetadataPayloadOfIdentity
	Payload IsMetadataPayload `protobuf_oneof:"payload"`
}

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

var xxx_messageInfo_Metadata proto.InternalMessageInfo

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

type MetadataPayloadOfIdentity struct {
	Identity *MetadataPayloadIdentityPayload `protobuf:"bytes,1,opt,name=identity,proto3,oneof" json:"identity,omitempty"`
}

func (*MetadataPayloadOfIdentity) IsMetadataPayload() {}

func (m *Metadata) GetPayload() IsMetadataPayload {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *Metadata) GetIdentity() *MetadataPayloadIdentityPayload {
	if x, ok := m.GetPayload().(*MetadataPayloadOfIdentity); ok {
		return x.Identity
	}
	return nil
}

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

type MetadataPayload struct {
}

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

var xxx_messageInfo_MetadataPayload proto.InternalMessageInfo

type MetadataPayloadIdentityPayload struct {
	ProfileSymKey []byte `protobuf:"bytes,1,opt,name=profileSymKey,proto3" json:"profileSymKey,omitempty"`
}

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

var xxx_messageInfo_MetadataPayloadIdentityPayload proto.InternalMessageInfo

func (m *MetadataPayloadIdentityPayload) GetProfileSymKey() []byte {
	if m != nil {
		return m.ProfileSymKey
	}
	return nil
}

type Notification struct {
	Id         string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CreateTime int64              `protobuf:"varint,2,opt,name=createTime,proto3" json:"createTime,omitempty"`
	Status     NotificationStatus `protobuf:"varint,4,opt,name=status,proto3,enum=anytype.model.NotificationStatus" json:"status,omitempty"`
	IsLocal    bool               `protobuf:"varint,5,opt,name=isLocal,proto3" json:"isLocal,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*NotificationPayloadOfImport
	//	*NotificationPayloadOfExport
	//	*NotificationPayloadOfGalleryImport
	//	*NotificationPayloadOfRequestToJoin
	//	*NotificationPayloadOfTest
	//	*NotificationPayloadOfParticipantRequestApproved
	//	*NotificationPayloadOfRequestToLeave
	//	*NotificationPayloadOfParticipantRemove
	//	*NotificationPayloadOfParticipantRequestDecline
	//	*NotificationPayloadOfParticipantPermissionsChange
	Payload   IsNotificationPayload `protobuf_oneof:"payload"`
	Space     string                `protobuf:"bytes,7,opt,name=space,proto3" json:"space,omitempty"`
	AclHeadId string                `protobuf:"bytes,14,opt,name=aclHeadId,proto3" json:"aclHeadId,omitempty"`
}

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

var xxx_messageInfo_Notification proto.InternalMessageInfo

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

type NotificationPayloadOfImport struct {
	Import *NotificationImport `protobuf:"bytes,6,opt,name=import,proto3,oneof" json:"import,omitempty"`
}
type NotificationPayloadOfExport struct {
	Export *NotificationExport `protobuf:"bytes,8,opt,name=export,proto3,oneof" json:"export,omitempty"`
}
type NotificationPayloadOfGalleryImport struct {
	GalleryImport *NotificationGalleryImport `protobuf:"bytes,9,opt,name=galleryImport,proto3,oneof" json:"galleryImport,omitempty"`
}
type NotificationPayloadOfRequestToJoin struct {
	RequestToJoin *NotificationRequestToJoin `protobuf:"bytes,10,opt,name=requestToJoin,proto3,oneof" json:"requestToJoin,omitempty"`
}
type NotificationPayloadOfTest struct {
	Test *NotificationTest `protobuf:"bytes,11,opt,name=test,proto3,oneof" json:"test,omitempty"`
}
type NotificationPayloadOfParticipantRequestApproved struct {
	ParticipantRequestApproved *NotificationParticipantRequestApproved `protobuf:"bytes,13,opt,name=participantRequestApproved,proto3,oneof" json:"participantRequestApproved,omitempty"`
}
type NotificationPayloadOfRequestToLeave struct {
	RequestToLeave *NotificationRequestToLeave `protobuf:"bytes,15,opt,name=requestToLeave,proto3,oneof" json:"requestToLeave,omitempty"`
}
type NotificationPayloadOfParticipantRemove struct {
	ParticipantRemove *NotificationParticipantRemove `protobuf:"bytes,16,opt,name=participantRemove,proto3,oneof" json:"participantRemove,omitempty"`
}
type NotificationPayloadOfParticipantRequestDecline struct {
	ParticipantRequestDecline *NotificationParticipantRequestDecline `protobuf:"bytes,17,opt,name=participantRequestDecline,proto3,oneof" json:"participantRequestDecline,omitempty"`
}
type NotificationPayloadOfParticipantPermissionsChange struct {
	ParticipantPermissionsChange *NotificationParticipantPermissionsChange `protobuf:"bytes,18,opt,name=participantPermissionsChange,proto3,oneof" json:"participantPermissionsChange,omitempty"`
}

func (*NotificationPayloadOfImport) IsNotificationPayload()                       {}
func (*NotificationPayloadOfExport) IsNotificationPayload()                       {}
func (*NotificationPayloadOfGalleryImport) IsNotificationPayload()                {}
func (*NotificationPayloadOfRequestToJoin) IsNotificationPayload()                {}
func (*NotificationPayloadOfTest) IsNotificationPayload()                         {}
func (*NotificationPayloadOfParticipantRequestApproved) IsNotificationPayload()   {}
func (*NotificationPayloadOfRequestToLeave) IsNotificationPayload()               {}
func (*NotificationPayloadOfParticipantRemove) IsNotificationPayload()            {}
func (*NotificationPayloadOfParticipantRequestDecline) IsNotificationPayload()    {}
func (*NotificationPayloadOfParticipantPermissionsChange) IsNotificationPayload() {}

func (m *Notification) GetPayload() IsNotificationPayload {
	if m != nil {
		return m.Payload
	}
	return nil
}

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

func (m *Notification) GetCreateTime() int64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

func (m *Notification) GetStatus() NotificationStatus {
	if m != nil {
		return m.Status
	}
	return Notification_Created
}

func (m *Notification) GetIsLocal() bool {
	if m != nil {
		return m.IsLocal
	}
	return false
}

func (m *Notification) GetImport() *NotificationImport {
	if x, ok := m.GetPayload().(*NotificationPayloadOfImport); ok {
		return x.Import
	}
	return nil
}

func (m *Notification) GetExport() *NotificationExport {
	if x, ok := m.GetPayload().(*NotificationPayloadOfExport); ok {
		return x.Export
	}
	return nil
}

func (m *Notification) GetGalleryImport() *NotificationGalleryImport {
	if x, ok := m.GetPayload().(*NotificationPayloadOfGalleryImport); ok {
		return x.GalleryImport
	}
	return nil
}

func (m *Notification) GetRequestToJoin() *NotificationRequestToJoin {
	if x, ok := m.GetPayload().(*NotificationPayloadOfRequestToJoin); ok {
		return x.RequestToJoin
	}
	return nil
}

func (m *Notification) GetTest() *NotificationTest {
	if x, ok := m.GetPayload().(*NotificationPayloadOfTest); ok {
		return x.Test
	}
	return nil
}

func (m *Notification) GetParticipantRequestApproved() *NotificationParticipantRequestApproved {
	if x, ok := m.GetPayload().(*NotificationPayloadOfParticipantRequestApproved); ok {
		return x.ParticipantRequestApproved
	}
	return nil
}

func (m *Notification) GetRequestToLeave() *NotificationRequestToLeave {
	if x, ok := m.GetPayload().(*NotificationPayloadOfRequestToLeave); ok {
		return x.RequestToLeave
	}
	return nil
}

func (m *Notification) GetParticipantRemove() *NotificationParticipantRemove {
	if x, ok := m.GetPayload().(*NotificationPayloadOfParticipantRemove); ok {
		return x.ParticipantRemove
	}
	return nil
}

func (m *Notification) GetParticipantRequestDecline() *NotificationParticipantRequestDecline {
	if x, ok := m.GetPayload().(*NotificationPayloadOfParticipantRequestDecline); ok {
		return x.ParticipantRequestDecline
	}
	return nil
}

func (m *Notification) GetParticipantPermissionsChange() *NotificationParticipantPermissionsChange {
	if x, ok := m.GetPayload().(*NotificationPayloadOfParticipantPermissionsChange); ok {
		return x.ParticipantPermissionsChange
	}
	return nil
}

func (m *Notification) GetSpace() string {
	if m != nil {
		return m.Space
	}
	return ""
}

func (m *Notification) GetAclHeadId() string {
	if m != nil {
		return m.AclHeadId
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Notification) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*NotificationPayloadOfImport)(nil),
		(*NotificationPayloadOfExport)(nil),
		(*NotificationPayloadOfGalleryImport)(nil),
		(*NotificationPayloadOfRequestToJoin)(nil),
		(*NotificationPayloadOfTest)(nil),
		(*NotificationPayloadOfParticipantRequestApproved)(nil),
		(*NotificationPayloadOfRequestToLeave)(nil),
		(*NotificationPayloadOfParticipantRemove)(nil),
		(*NotificationPayloadOfParticipantRequestDecline)(nil),
		(*NotificationPayloadOfParticipantPermissionsChange)(nil),
	}
}

type NotificationImport struct {
	ProcessId  string          `protobuf:"bytes,1,opt,name=processId,proto3" json:"processId,omitempty"`
	ErrorCode  ImportErrorCode `protobuf:"varint,2,opt,name=errorCode,proto3,enum=anytype.model.ImportErrorCode" json:"errorCode,omitempty"`
	ImportType ImportType      `protobuf:"varint,3,opt,name=importType,proto3,enum=anytype.model.ImportType" json:"importType,omitempty"`
	SpaceId    string          `protobuf:"bytes,4,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Name       string          `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
	SpaceName  string          `protobuf:"bytes,6,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationImport proto.InternalMessageInfo

func (m *NotificationImport) GetProcessId() string {
	if m != nil {
		return m.ProcessId
	}
	return ""
}

func (m *NotificationImport) GetErrorCode() ImportErrorCode {
	if m != nil {
		return m.ErrorCode
	}
	return Import_NULL
}

func (m *NotificationImport) GetImportType() ImportType {
	if m != nil {
		return m.ImportType
	}
	return Import_Notion
}

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

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

func (m *NotificationImport) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationExport struct {
	ErrorCode  NotificationExportCode `protobuf:"varint,2,opt,name=errorCode,proto3,enum=anytype.model.NotificationExportCode" json:"errorCode,omitempty"`
	ExportType ExportFormat           `protobuf:"varint,3,opt,name=exportType,proto3,enum=anytype.model.ExportFormat" json:"exportType,omitempty"`
}

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

var xxx_messageInfo_NotificationExport proto.InternalMessageInfo

func (m *NotificationExport) GetErrorCode() NotificationExportCode {
	if m != nil {
		return m.ErrorCode
	}
	return NotificationExport_NULL
}

func (m *NotificationExport) GetExportType() ExportFormat {
	if m != nil {
		return m.ExportType
	}
	return Export_Markdown
}

type NotificationGalleryImport struct {
	ProcessId string          `protobuf:"bytes,1,opt,name=processId,proto3" json:"processId,omitempty"`
	ErrorCode ImportErrorCode `protobuf:"varint,2,opt,name=errorCode,proto3,enum=anytype.model.ImportErrorCode" json:"errorCode,omitempty"`
	SpaceId   string          `protobuf:"bytes,3,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Name      string          `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	SpaceName string          `protobuf:"bytes,5,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationGalleryImport proto.InternalMessageInfo

func (m *NotificationGalleryImport) GetProcessId() string {
	if m != nil {
		return m.ProcessId
	}
	return ""
}

func (m *NotificationGalleryImport) GetErrorCode() ImportErrorCode {
	if m != nil {
		return m.ErrorCode
	}
	return Import_NULL
}

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

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

func (m *NotificationGalleryImport) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationRequestToJoin struct {
	SpaceId      string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Identity     string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
	IdentityName string `protobuf:"bytes,3,opt,name=identityName,proto3" json:"identityName,omitempty"`
	IdentityIcon string `protobuf:"bytes,4,opt,name=identityIcon,proto3" json:"identityIcon,omitempty"`
	SpaceName    string `protobuf:"bytes,5,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationRequestToJoin proto.InternalMessageInfo

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

func (m *NotificationRequestToJoin) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *NotificationRequestToJoin) GetIdentityName() string {
	if m != nil {
		return m.IdentityName
	}
	return ""
}

func (m *NotificationRequestToJoin) GetIdentityIcon() string {
	if m != nil {
		return m.IdentityIcon
	}
	return ""
}

func (m *NotificationRequestToJoin) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationTest struct {
}

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

var xxx_messageInfo_NotificationTest proto.InternalMessageInfo

type NotificationParticipantRequestApproved struct {
	SpaceId     string                 `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Permissions ParticipantPermissions `protobuf:"varint,2,opt,name=permissions,proto3,enum=anytype.model.ParticipantPermissions" json:"permissions,omitempty"`
	SpaceName   string                 `protobuf:"bytes,5,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationParticipantRequestApproved proto.InternalMessageInfo

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

func (m *NotificationParticipantRequestApproved) GetPermissions() ParticipantPermissions {
	if m != nil {
		return m.Permissions
	}
	return ParticipantPermissions_Reader
}

func (m *NotificationParticipantRequestApproved) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationRequestToLeave struct {
	SpaceId      string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Identity     string `protobuf:"bytes,2,opt,name=identity,proto3" json:"identity,omitempty"`
	IdentityName string `protobuf:"bytes,3,opt,name=identityName,proto3" json:"identityName,omitempty"`
	IdentityIcon string `protobuf:"bytes,4,opt,name=identityIcon,proto3" json:"identityIcon,omitempty"`
	SpaceName    string `protobuf:"bytes,5,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationRequestToLeave proto.InternalMessageInfo

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

func (m *NotificationRequestToLeave) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *NotificationRequestToLeave) GetIdentityName() string {
	if m != nil {
		return m.IdentityName
	}
	return ""
}

func (m *NotificationRequestToLeave) GetIdentityIcon() string {
	if m != nil {
		return m.IdentityIcon
	}
	return ""
}

func (m *NotificationRequestToLeave) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationParticipantRemove struct {
	Identity     string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	IdentityName string `protobuf:"bytes,2,opt,name=identityName,proto3" json:"identityName,omitempty"`
	IdentityIcon string `protobuf:"bytes,3,opt,name=identityIcon,proto3" json:"identityIcon,omitempty"`
	SpaceId      string `protobuf:"bytes,4,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	SpaceName    string `protobuf:"bytes,5,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationParticipantRemove proto.InternalMessageInfo

func (m *NotificationParticipantRemove) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

func (m *NotificationParticipantRemove) GetIdentityName() string {
	if m != nil {
		return m.IdentityName
	}
	return ""
}

func (m *NotificationParticipantRemove) GetIdentityIcon() string {
	if m != nil {
		return m.IdentityIcon
	}
	return ""
}

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

func (m *NotificationParticipantRemove) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationParticipantRequestDecline struct {
	SpaceId   string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	SpaceName string `protobuf:"bytes,3,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationParticipantRequestDecline proto.InternalMessageInfo

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

func (m *NotificationParticipantRequestDecline) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type NotificationParticipantPermissionsChange struct {
	SpaceId     string                 `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	Permissions ParticipantPermissions `protobuf:"varint,2,opt,name=permissions,proto3,enum=anytype.model.ParticipantPermissions" json:"permissions,omitempty"`
	SpaceName   string                 `protobuf:"bytes,3,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
}

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

var xxx_messageInfo_NotificationParticipantPermissionsChange proto.InternalMessageInfo

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

func (m *NotificationParticipantPermissionsChange) GetPermissions() ParticipantPermissions {
	if m != nil {
		return m.Permissions
	}
	return ParticipantPermissions_Reader
}

func (m *NotificationParticipantPermissionsChange) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

type Export struct {
}

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

var xxx_messageInfo_Export proto.InternalMessageInfo

type Import struct {
}

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

var xxx_messageInfo_Import proto.InternalMessageInfo

type Invite struct {
	Payload   []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}

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

var xxx_messageInfo_Invite proto.InternalMessageInfo

func (m *Invite) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *Invite) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

type InvitePayload struct {
	CreatorIdentity         string               `protobuf:"bytes,1,opt,name=creatorIdentity,proto3" json:"creatorIdentity,omitempty"`
	CreatorName             string               `protobuf:"bytes,2,opt,name=creatorName,proto3" json:"creatorName,omitempty"`
	AclKey                  []byte               `protobuf:"bytes,3,opt,name=aclKey,proto3" json:"aclKey,omitempty"`
	SpaceId                 string               `protobuf:"bytes,4,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	SpaceName               string               `protobuf:"bytes,5,opt,name=spaceName,proto3" json:"spaceName,omitempty"`
	SpaceIconCid            string               `protobuf:"bytes,6,opt,name=spaceIconCid,proto3" json:"spaceIconCid,omitempty"`
	SpaceIconEncryptionKeys []*FileEncryptionKey `protobuf:"bytes,7,rep,name=spaceIconEncryptionKeys,proto3" json:"spaceIconEncryptionKeys,omitempty"`
	InviteType              InviteType           `protobuf:"varint,8,opt,name=inviteType,proto3,enum=anytype.model.InviteType" json:"inviteType,omitempty"`
	GuestKey                []byte               `protobuf:"bytes,9,opt,name=guestKey,proto3" json:"guestKey,omitempty"`
}

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

var xxx_messageInfo_InvitePayload proto.InternalMessageInfo

func (m *InvitePayload) GetCreatorIdentity() string {
	if m != nil {
		return m.CreatorIdentity
	}
	return ""
}

func (m *InvitePayload) GetCreatorName() string {
	if m != nil {
		return m.CreatorName
	}
	return ""
}

func (m *InvitePayload) GetAclKey() []byte {
	if m != nil {
		return m.AclKey
	}
	return nil
}

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

func (m *InvitePayload) GetSpaceName() string {
	if m != nil {
		return m.SpaceName
	}
	return ""
}

func (m *InvitePayload) GetSpaceIconCid() string {
	if m != nil {
		return m.SpaceIconCid
	}
	return ""
}

func (m *InvitePayload) GetSpaceIconEncryptionKeys() []*FileEncryptionKey {
	if m != nil {
		return m.SpaceIconEncryptionKeys
	}
	return nil
}

func (m *InvitePayload) GetInviteType() InviteType {
	if m != nil {
		return m.InviteType
	}
	return InviteType_Member
}

func (m *InvitePayload) GetGuestKey() []byte {
	if m != nil {
		return m.GuestKey
	}
	return nil
}

type IdentityProfile struct {
	Identity           string               `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	Name               string               `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	IconCid            string               `protobuf:"bytes,3,opt,name=iconCid,proto3" json:"iconCid,omitempty"`
	IconEncryptionKeys []*FileEncryptionKey `protobuf:"bytes,4,rep,name=iconEncryptionKeys,proto3" json:"iconEncryptionKeys,omitempty"`
	Description        string               `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	GlobalName         string               `protobuf:"bytes,6,opt,name=globalName,proto3" json:"globalName,omitempty"`
}

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

var xxx_messageInfo_IdentityProfile proto.InternalMessageInfo

func (m *IdentityProfile) GetIdentity() string {
	if m != nil {
		return m.Identity
	}
	return ""
}

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

func (m *IdentityProfile) GetIconCid() string {
	if m != nil {
		return m.IconCid
	}
	return ""
}

func (m *IdentityProfile) GetIconEncryptionKeys() []*FileEncryptionKey {
	if m != nil {
		return m.IconEncryptionKeys
	}
	return nil
}

func (m *IdentityProfile) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *IdentityProfile) GetGlobalName() string {
	if m != nil {
		return m.GlobalName
	}
	return ""
}

type FileInfo struct {
	FileId         string               `protobuf:"bytes,1,opt,name=fileId,proto3" json:"fileId,omitempty"`
	EncryptionKeys []*FileEncryptionKey `protobuf:"bytes,2,rep,name=encryptionKeys,proto3" json:"encryptionKeys,omitempty"`
}

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

var xxx_messageInfo_FileInfo proto.InternalMessageInfo

func (m *FileInfo) GetFileId() string {
	if m != nil {
		return m.FileId
	}
	return ""
}

func (m *FileInfo) GetEncryptionKeys() []*FileEncryptionKey {
	if m != nil {
		return m.EncryptionKeys
	}
	return nil
}

type FileEncryptionKey struct {
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Key  string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_FileEncryptionKey proto.InternalMessageInfo

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

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

type ManifestInfo struct {
	Schema       string   `protobuf:"bytes,1,opt,name=schema,json=$schema,proto3" json:"schema,omitempty"`
	Id           string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Name         string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Author       string   `protobuf:"bytes,4,opt,name=author,proto3" json:"author,omitempty"`
	License      string   `protobuf:"bytes,5,opt,name=license,proto3" json:"license,omitempty"`
	Title        string   `protobuf:"bytes,6,opt,name=title,proto3" json:"title,omitempty"`
	Description  string   `protobuf:"bytes,7,opt,name=description,proto3" json:"description,omitempty"`
	Screenshots  []string `protobuf:"bytes,8,rep,name=screenshots,proto3" json:"screenshots,omitempty"`
	DownloadLink string   `protobuf:"bytes,9,opt,name=downloadLink,proto3" json:"downloadLink,omitempty"`
	FileSize     int32    `protobuf:"varint,10,opt,name=fileSize,proto3" json:"fileSize,omitempty"`
	Categories   []string `protobuf:"bytes,11,rep,name=categories,proto3" json:"categories,omitempty"`
	Language     string   `protobuf:"bytes,12,opt,name=language,proto3" json:"language,omitempty"`
}

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

var xxx_messageInfo_ManifestInfo proto.InternalMessageInfo

func (m *ManifestInfo) GetSchema() string {
	if m != nil {
		return m.Schema
	}
	return ""
}

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

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

func (m *ManifestInfo) GetAuthor() string {
	if m != nil {
		return m.Author
	}
	return ""
}

func (m *ManifestInfo) GetLicense() string {
	if m != nil {
		return m.License
	}
	return ""
}

func (m *ManifestInfo) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *ManifestInfo) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *ManifestInfo) GetScreenshots() []string {
	if m != nil {
		return m.Screenshots
	}
	return nil
}

func (m *ManifestInfo) GetDownloadLink() string {
	if m != nil {
		return m.DownloadLink
	}
	return ""
}

func (m *ManifestInfo) GetFileSize() int32 {
	if m != nil {
		return m.FileSize
	}
	return 0
}

func (m *ManifestInfo) GetCategories() []string {
	if m != nil {
		return m.Categories
	}
	return nil
}

func (m *ManifestInfo) GetLanguage() string {
	if m != nil {
		return m.Language
	}
	return ""
}

type Membership struct {
	// it was Tier before, changed to int32 to allow dynamic values
	Tier          uint32                  `protobuf:"varint,1,opt,name=tier,proto3" json:"tier,omitempty"`
	Status        MembershipStatus        `protobuf:"varint,2,opt,name=status,proto3,enum=anytype.model.MembershipStatus" json:"status,omitempty"`
	DateStarted   uint64                  `protobuf:"varint,3,opt,name=dateStarted,proto3" json:"dateStarted,omitempty"`
	DateEnds      uint64                  `protobuf:"varint,4,opt,name=dateEnds,proto3" json:"dateEnds,omitempty"`
	IsAutoRenew   bool                    `protobuf:"varint,5,opt,name=isAutoRenew,proto3" json:"isAutoRenew,omitempty"`
	PaymentMethod MembershipPaymentMethod `protobuf:"varint,6,opt,name=paymentMethod,proto3,enum=anytype.model.MembershipPaymentMethod" json:"paymentMethod,omitempty"`
	// can be empty if user did not ask for any name
	NsName     string              `protobuf:"bytes,7,opt,name=nsName,proto3" json:"nsName,omitempty"`
	NsNameType NameserviceNameType `protobuf:"varint,8,opt,name=nsNameType,proto3,enum=anytype.model.NameserviceNameType" json:"nsNameType,omitempty"`
	// if the email was verified by the user or set during the checkout - it will be here
	UserEmail             string `protobuf:"bytes,9,opt,name=userEmail,proto3" json:"userEmail,omitempty"`
	SubscribeToNewsletter bool   `protobuf:"varint,10,opt,name=subscribeToNewsletter,proto3" json:"subscribeToNewsletter,omitempty"`
}

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

var xxx_messageInfo_Membership proto.InternalMessageInfo

func (m *Membership) GetTier() uint32 {
	if m != nil {
		return m.Tier
	}
	return 0
}

func (m *Membership) GetStatus() MembershipStatus {
	if m != nil {
		return m.Status
	}
	return Membership_StatusUnknown
}

func (m *Membership) GetDateStarted() uint64 {
	if m != nil {
		return m.DateStarted
	}
	return 0
}

func (m *Membership) GetDateEnds() uint64 {
	if m != nil {
		return m.DateEnds
	}
	return 0
}

func (m *Membership) GetIsAutoRenew() bool {
	if m != nil {
		return m.IsAutoRenew
	}
	return false
}

func (m *Membership) GetPaymentMethod() MembershipPaymentMethod {
	if m != nil {
		return m.PaymentMethod
	}
	return Membership_MethodNone
}

func (m *Membership) GetNsName() string {
	if m != nil {
		return m.NsName
	}
	return ""
}

func (m *Membership) GetNsNameType() NameserviceNameType {
	if m != nil {
		return m.NsNameType
	}
	return NameserviceNameType_AnyName
}

func (m *Membership) GetUserEmail() string {
	if m != nil {
		return m.UserEmail
	}
	return ""
}

func (m *Membership) GetSubscribeToNewsletter() bool {
	if m != nil {
		return m.SubscribeToNewsletter
	}
	return false
}

type MembershipTierData struct {
	// this is a unique Payment Node ID of the tier
	// WARNING: tiers can be sorted differently, not according to their IDs!
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// localazied name of the tier
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// just a short technical description
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// is this tier for testing and debugging only?
	IsTest bool `protobuf:"varint,4,opt,name=isTest,proto3" json:"isTest,omitempty"`
	// how long is the period of the subscription
	PeriodType MembershipTierDataPeriodType `protobuf:"varint,5,opt,name=periodType,proto3,enum=anytype.model.MembershipTierDataPeriodType" json:"periodType,omitempty"`
	// i.e. "5 days" or "3 years"
	PeriodValue uint32 `protobuf:"varint,6,opt,name=periodValue,proto3" json:"periodValue,omitempty"`
	// this one is a price we use ONLY on Stripe platform
	PriceStripeUsdCents uint32 `protobuf:"varint,7,opt,name=priceStripeUsdCents,proto3" json:"priceStripeUsdCents,omitempty"`
	// number of ANY NS names that this tier includes
	// also in the "features" list (see below)
	AnyNamesCountIncluded uint32 `protobuf:"varint,8,opt,name=anyNamesCountIncluded,proto3" json:"anyNamesCountIncluded,omitempty"`
	// somename.any - is of len 8
	AnyNameMinLength uint32 `protobuf:"varint,9,opt,name=anyNameMinLength,proto3" json:"anyNameMinLength,omitempty"`
	// localized strings for the features
	Features []string `protobuf:"bytes,10,rep,name=features,proto3" json:"features,omitempty"`
	// green, blue, red, purple, custom
	ColorStr string `protobuf:"bytes,11,opt,name=colorStr,proto3" json:"colorStr,omitempty"`
	// Stripe platform-specific data:
	StripeProductId string `protobuf:"bytes,12,opt,name=stripeProductId,proto3" json:"stripeProductId,omitempty"`
	StripeManageUrl string `protobuf:"bytes,13,opt,name=stripeManageUrl,proto3" json:"stripeManageUrl,omitempty"`
	// iOS platform-specific data:
	IosProductId string `protobuf:"bytes,15,opt,name=iosProductId,proto3" json:"iosProductId,omitempty"`
	IosManageUrl string `protobuf:"bytes,16,opt,name=iosManageUrl,proto3" json:"iosManageUrl,omitempty"`
	// Android platform-specific data:
	AndroidProductId string `protobuf:"bytes,17,opt,name=androidProductId,proto3" json:"androidProductId,omitempty"`
	AndroidManageUrl string `protobuf:"bytes,18,opt,name=androidManageUrl,proto3" json:"androidManageUrl,omitempty"`
	// "limited offer" or somehing like that
	Offer string `protobuf:"bytes,19,opt,name=offer,proto3" json:"offer,omitempty"`
}

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

var xxx_messageInfo_MembershipTierData proto.InternalMessageInfo

func (m *MembershipTierData) GetId() uint32 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

func (m *MembershipTierData) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *MembershipTierData) GetIsTest() bool {
	if m != nil {
		return m.IsTest
	}
	return false
}

func (m *MembershipTierData) GetPeriodType() MembershipTierDataPeriodType {
	if m != nil {
		return m.PeriodType
	}
	return MembershipTierData_PeriodTypeUnknown
}

func (m *MembershipTierData) GetPeriodValue() uint32 {
	if m != nil {
		return m.PeriodValue
	}
	return 0
}

func (m *MembershipTierData) GetPriceStripeUsdCents() uint32 {
	if m != nil {
		return m.PriceStripeUsdCents
	}
	return 0
}

func (m *MembershipTierData) GetAnyNamesCountIncluded() uint32 {
	if m != nil {
		return m.AnyNamesCountIncluded
	}
	return 0
}

func (m *MembershipTierData) GetAnyNameMinLength() uint32 {
	if m != nil {
		return m.AnyNameMinLength
	}
	return 0
}

func (m *MembershipTierData) GetFeatures() []string {
	if m != nil {
		return m.Features
	}
	return nil
}

func (m *MembershipTierData) GetColorStr() string {
	if m != nil {
		return m.ColorStr
	}
	return ""
}

func (m *MembershipTierData) GetStripeProductId() string {
	if m != nil {
		return m.StripeProductId
	}
	return ""
}

func (m *MembershipTierData) GetStripeManageUrl() string {
	if m != nil {
		return m.StripeManageUrl
	}
	return ""
}

func (m *MembershipTierData) GetIosProductId() string {
	if m != nil {
		return m.IosProductId
	}
	return ""
}

func (m *MembershipTierData) GetIosManageUrl() string {
	if m != nil {
		return m.IosManageUrl
	}
	return ""
}

func (m *MembershipTierData) GetAndroidProductId() string {
	if m != nil {
		return m.AndroidProductId
	}
	return ""
}

func (m *MembershipTierData) GetAndroidManageUrl() string {
	if m != nil {
		return m.AndroidManageUrl
	}
	return ""
}

func (m *MembershipTierData) GetOffer() string {
	if m != nil {
		return m.Offer
	}
	return ""
}

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

var xxx_messageInfo_Detail proto.InternalMessageInfo

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

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

type DeviceInfo 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"`
	AddDate     int64  `protobuf:"varint,3,opt,name=addDate,proto3" json:"addDate,omitempty"`
	Archived    bool   `protobuf:"varint,4,opt,name=archived,proto3" json:"archived,omitempty"`
	IsConnected bool   `protobuf:"varint,5,opt,name=isConnected,proto3" json:"isConnected,omitempty"`
}

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

var xxx_messageInfo_DeviceInfo proto.InternalMessageInfo

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

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

func (m *DeviceInfo) GetAddDate() int64 {
	if m != nil {
		return m.AddDate
	}
	return 0
}

func (m *DeviceInfo) GetArchived() bool {
	if m != nil {
		return m.Archived
	}
	return false
}

func (m *DeviceInfo) GetIsConnected() bool {
	if m != nil {
		return m.IsConnected
	}
	return false
}

type ChatState struct {
	Messages    *ChatStateUnreadState `protobuf:"bytes,1,opt,name=messages,proto3" json:"messages,omitempty"`
	Mentions    *ChatStateUnreadState `protobuf:"bytes,2,opt,name=mentions,proto3" json:"mentions,omitempty"`
	LastStateId string                `protobuf:"bytes,3,opt,name=lastStateId,proto3" json:"lastStateId,omitempty"`
	Order       int64                 `protobuf:"varint,4,opt,name=order,proto3" json:"order,omitempty"`
}

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

var xxx_messageInfo_ChatState proto.InternalMessageInfo

func (m *ChatState) GetMessages() *ChatStateUnreadState {
	if m != nil {
		return m.Messages
	}
	return nil
}

func (m *ChatState) GetMentions() *ChatStateUnreadState {
	if m != nil {
		return m.Mentions
	}
	return nil
}

func (m *ChatState) GetLastStateId() string {
	if m != nil {
		return m.LastStateId
	}
	return ""
}

func (m *ChatState) GetOrder() int64 {
	if m != nil {
		return m.Order
	}
	return 0
}

type ChatStateUnreadState struct {
	OldestOrderId string `protobuf:"bytes,1,opt,name=oldestOrderId,proto3" json:"oldestOrderId,omitempty"`
	Counter       int32  `protobuf:"varint,2,opt,name=counter,proto3" json:"counter,omitempty"`
}

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

var xxx_messageInfo_ChatStateUnreadState proto.InternalMessageInfo

func (m *ChatStateUnreadState) GetOldestOrderId() string {
	if m != nil {
		return m.OldestOrderId
	}
	return ""
}

func (m *ChatStateUnreadState) GetCounter() int32 {
	if m != nil {
		return m.Counter
	}
	return 0
}

type ChatMessage 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"`
	Creator    string `protobuf:"bytes,3,opt,name=creator,proto3" json:"creator,omitempty"`
	CreatedAt  int64  `protobuf:"varint,4,opt,name=createdAt,proto3" json:"createdAt,omitempty"`
	ModifiedAt int64  `protobuf:"varint,9,opt,name=modifiedAt,proto3" json:"modifiedAt,omitempty"`
	// stateId is ever-increasing id (BSON ObjectId) for this message. Unlike orderId, this ID is ordered by the time messages are added. For example, it's useful to prevent accidental reading of messages from the past when a ChatReadMessages request is sent: a message from the past may appear, but the client is still unaware of it
	StateId          string                     `protobuf:"bytes,11,opt,name=stateId,proto3" json:"stateId,omitempty"`
	ReplyToMessageId string                     `protobuf:"bytes,5,opt,name=replyToMessageId,proto3" json:"replyToMessageId,omitempty"`
	Message          *ChatMessageMessageContent `protobuf:"bytes,6,opt,name=message,proto3" json:"message,omitempty"`
	Attachments      []*ChatMessageAttachment   `protobuf:"bytes,7,rep,name=attachments,proto3" json:"attachments,omitempty"`
	Reactions        *ChatMessageReactions      `protobuf:"bytes,8,opt,name=reactions,proto3" json:"reactions,omitempty"`
	Read             bool                       `protobuf:"varint,10,opt,name=read,proto3" json:"read,omitempty"`
	MentionRead      bool                       `protobuf:"varint,12,opt,name=mentionRead,proto3" json:"mentionRead,omitempty"`
	HasMention       bool                       `protobuf:"varint,14,opt,name=hasMention,proto3" json:"hasMention,omitempty"`
	Synced           bool                       `protobuf:"varint,13,opt,name=synced,proto3" json:"synced,omitempty"`
}

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

var xxx_messageInfo_ChatMessage proto.InternalMessageInfo

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

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

func (m *ChatMessage) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *ChatMessage) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *ChatMessage) GetModifiedAt() int64 {
	if m != nil {
		return m.ModifiedAt
	}
	return 0
}

func (m *ChatMessage) GetStateId() string {
	if m != nil {
		return m.StateId
	}
	return ""
}

func (m *ChatMessage) GetReplyToMessageId() string {
	if m != nil {
		return m.ReplyToMessageId
	}
	return ""
}

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

func (m *ChatMessage) GetAttachments() []*ChatMessageAttachment {
	if m != nil {
		return m.Attachments
	}
	return nil
}

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

func (m *ChatMessage) GetRead() bool {
	if m != nil {
		return m.Read
	}
	return false
}

func (m *ChatMessage) GetMentionRead() bool {
	if m != nil {
		return m.MentionRead
	}
	return false
}

func (m *ChatMessage) GetHasMention() bool {
	if m != nil {
		return m.HasMention
	}
	return false
}

func (m *ChatMessage) GetSynced() bool {
	if m != nil {
		return m.Synced
	}
	return false
}

type ChatMessageMessageContent struct {
	Text  string                  `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
	Style BlockContentTextStyle   `protobuf:"varint,2,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle" json:"style,omitempty"`
	Marks []*BlockContentTextMark `protobuf:"bytes,3,rep,name=marks,proto3" json:"marks,omitempty"`
}

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

var xxx_messageInfo_ChatMessageMessageContent proto.InternalMessageInfo

func (m *ChatMessageMessageContent) GetText() string {
	if m != nil {
		return m.Text
	}
	return ""
}

func (m *ChatMessageMessageContent) GetStyle() BlockContentTextStyle {
	if m != nil {
		return m.Style
	}
	return BlockContentText_Paragraph
}

func (m *ChatMessageMessageContent) GetMarks() []*BlockContentTextMark {
	if m != nil {
		return m.Marks
	}
	return nil
}

type ChatMessageAttachment struct {
	Target string                              `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	Type   ChatMessageAttachmentAttachmentType `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.model.ChatMessageAttachmentAttachmentType" json:"type,omitempty"`
}

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

var xxx_messageInfo_ChatMessageAttachment proto.InternalMessageInfo

func (m *ChatMessageAttachment) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *ChatMessageAttachment) GetType() ChatMessageAttachmentAttachmentType {
	if m != nil {
		return m.Type
	}
	return ChatMessageAttachment_FILE
}

type ChatMessageReactions struct {
	Reactions map[string]*ChatMessageReactionsIdentityList `protobuf:"bytes,1,rep,name=reactions,proto3" json:"reactions,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ChatMessageReactions proto.InternalMessageInfo

func (m *ChatMessageReactions) GetReactions() map[string]*ChatMessageReactionsIdentityList {
	if m != nil {
		return m.Reactions
	}
	return nil
}

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

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

var xxx_messageInfo_ChatMessageReactionsIdentityList proto.InternalMessageInfo

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

func init() {
	proto.RegisterEnum("anytype.model.SmartBlockType", SmartBlockType_name, SmartBlockType_value)
	proto.RegisterEnum("anytype.model.RelationFormat", RelationFormat_name, RelationFormat_value)
	proto.RegisterEnum("anytype.model.ObjectOrigin", ObjectOrigin_name, ObjectOrigin_value)
	proto.RegisterEnum("anytype.model.SpaceStatus", SpaceStatus_name, SpaceStatus_value)
	proto.RegisterEnum("anytype.model.ParticipantPermissions", ParticipantPermissions_name, ParticipantPermissions_value)
	proto.RegisterEnum("anytype.model.InviteType", InviteType_name, InviteType_value)
	proto.RegisterEnum("anytype.model.ParticipantStatus", ParticipantStatus_name, ParticipantStatus_value)
	proto.RegisterEnum("anytype.model.SpaceAccessType", SpaceAccessType_name, SpaceAccessType_value)
	proto.RegisterEnum("anytype.model.SpaceUxType", SpaceUxType_name, SpaceUxType_value)
	proto.RegisterEnum("anytype.model.ImageKind", ImageKind_name, ImageKind_value)
	proto.RegisterEnum("anytype.model.FileIndexingStatus", FileIndexingStatus_name, FileIndexingStatus_value)
	proto.RegisterEnum("anytype.model.SpaceShareableStatus", SpaceShareableStatus_name, SpaceShareableStatus_value)
	proto.RegisterEnum("anytype.model.NameserviceNameType", NameserviceNameType_name, NameserviceNameType_value)
	proto.RegisterEnum("anytype.model.DeviceNetworkType", DeviceNetworkType_name, DeviceNetworkType_value)
	proto.RegisterEnum("anytype.model.SyncStatus", SyncStatus_name, SyncStatus_value)
	proto.RegisterEnum("anytype.model.SyncError", SyncError_name, SyncError_value)
	proto.RegisterEnum("anytype.model.BlockPosition", BlockPosition_name, BlockPosition_value)
	proto.RegisterEnum("anytype.model.BlockAlign", BlockAlign_name, BlockAlign_value)
	proto.RegisterEnum("anytype.model.BlockVerticalAlign", BlockVerticalAlign_name, BlockVerticalAlign_value)
	proto.RegisterEnum("anytype.model.BlockContentLayoutStyle", BlockContentLayoutStyle_name, BlockContentLayoutStyle_value)
	proto.RegisterEnum("anytype.model.BlockContentLinkIconSize", BlockContentLinkIconSize_name, BlockContentLinkIconSize_value)
	proto.RegisterEnum("anytype.model.BlockContentLinkStyle", BlockContentLinkStyle_name, BlockContentLinkStyle_value)
	proto.RegisterEnum("anytype.model.BlockContentLinkDescription", BlockContentLinkDescription_name, BlockContentLinkDescription_value)
	proto.RegisterEnum("anytype.model.BlockContentLinkCardStyle", BlockContentLinkCardStyle_name, BlockContentLinkCardStyle_value)
	proto.RegisterEnum("anytype.model.BlockContentDivStyle", BlockContentDivStyle_name, BlockContentDivStyle_value)
	proto.RegisterEnum("anytype.model.BlockContentBookmarkState", BlockContentBookmarkState_name, BlockContentBookmarkState_value)
	proto.RegisterEnum("anytype.model.BlockContentTextStyle", BlockContentTextStyle_name, BlockContentTextStyle_value)
	proto.RegisterEnum("anytype.model.BlockContentTextMarkType", BlockContentTextMarkType_name, BlockContentTextMarkType_value)
	proto.RegisterEnum("anytype.model.BlockContentFileType", BlockContentFileType_name, BlockContentFileType_value)
	proto.RegisterEnum("anytype.model.BlockContentFileStyle", BlockContentFileStyle_name, BlockContentFileStyle_value)
	proto.RegisterEnum("anytype.model.BlockContentFileState", BlockContentFileState_name, BlockContentFileState_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewViewType", BlockContentDataviewViewType_name, BlockContentDataviewViewType_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewViewSize", BlockContentDataviewViewSize_name, BlockContentDataviewViewSize_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewRelationDateFormat", BlockContentDataviewRelationDateFormat_name, BlockContentDataviewRelationDateFormat_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewRelationTimeFormat", BlockContentDataviewRelationTimeFormat_name, BlockContentDataviewRelationTimeFormat_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewRelationFormulaType", BlockContentDataviewRelationFormulaType_name, BlockContentDataviewRelationFormulaType_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewSortType", BlockContentDataviewSortType_name, BlockContentDataviewSortType_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewSortEmptyType", BlockContentDataviewSortEmptyType_name, BlockContentDataviewSortEmptyType_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewFilterOperator", BlockContentDataviewFilterOperator_name, BlockContentDataviewFilterOperator_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewFilterCondition", BlockContentDataviewFilterCondition_name, BlockContentDataviewFilterCondition_value)
	proto.RegisterEnum("anytype.model.BlockContentDataviewFilterQuickOption", BlockContentDataviewFilterQuickOption_name, BlockContentDataviewFilterQuickOption_value)
	proto.RegisterEnum("anytype.model.BlockContentLatexProcessor", BlockContentLatexProcessor_name, BlockContentLatexProcessor_value)
	proto.RegisterEnum("anytype.model.BlockContentWidgetLayout", BlockContentWidgetLayout_name, BlockContentWidgetLayout_value)
	proto.RegisterEnum("anytype.model.AccountStatusType", AccountStatusType_name, AccountStatusType_value)
	proto.RegisterEnum("anytype.model.AccountAuthLocalApiScope", AccountAuthLocalApiScope_name, AccountAuthLocalApiScope_value)
	proto.RegisterEnum("anytype.model.LinkPreviewType", LinkPreviewType_name, LinkPreviewType_value)
	proto.RegisterEnum("anytype.model.RestrictionsObjectRestriction", RestrictionsObjectRestriction_name, RestrictionsObjectRestriction_value)
	proto.RegisterEnum("anytype.model.RestrictionsDataviewRestriction", RestrictionsDataviewRestriction_name, RestrictionsDataviewRestriction_value)
	proto.RegisterEnum("anytype.model.ObjectTypeLayout", ObjectTypeLayout_name, ObjectTypeLayout_value)
	proto.RegisterEnum("anytype.model.RelationScope", RelationScope_name, RelationScope_value)
	proto.RegisterEnum("anytype.model.RelationDataSource", RelationDataSource_name, RelationDataSource_value)
	proto.RegisterEnum("anytype.model.InternalFlagValue", InternalFlagValue_name, InternalFlagValue_value)
	proto.RegisterEnum("anytype.model.NotificationStatus", NotificationStatus_name, NotificationStatus_value)
	proto.RegisterEnum("anytype.model.NotificationActionType", NotificationActionType_name, NotificationActionType_value)
	proto.RegisterEnum("anytype.model.NotificationExportCode", NotificationExportCode_name, NotificationExportCode_value)
	proto.RegisterEnum("anytype.model.ExportFormat", ExportFormat_name, ExportFormat_value)
	proto.RegisterEnum("anytype.model.ImportType", ImportType_name, ImportType_value)
	proto.RegisterEnum("anytype.model.ImportErrorCode", ImportErrorCode_name, ImportErrorCode_value)
	proto.RegisterEnum("anytype.model.MembershipStatus", MembershipStatus_name, MembershipStatus_value)
	proto.RegisterEnum("anytype.model.MembershipPaymentMethod", MembershipPaymentMethod_name, MembershipPaymentMethod_value)
	proto.RegisterEnum("anytype.model.MembershipEmailVerificationStatus", MembershipEmailVerificationStatus_name, MembershipEmailVerificationStatus_value)
	proto.RegisterEnum("anytype.model.MembershipTierDataPeriodType", MembershipTierDataPeriodType_name, MembershipTierDataPeriodType_value)
	proto.RegisterEnum("anytype.model.ChatMessageAttachmentAttachmentType", ChatMessageAttachmentAttachmentType_name, ChatMessageAttachmentAttachmentType_value)
	proto.RegisterType((*SmartBlockSnapshotBase)(nil), "anytype.model.SmartBlockSnapshotBase")
	proto.RegisterType((*Search)(nil), "anytype.model.Search")
	proto.RegisterType((*SearchResult)(nil), "anytype.model.Search.Result")
	proto.RegisterType((*SearchMeta)(nil), "anytype.model.Search.Meta")
	proto.RegisterType((*Block)(nil), "anytype.model.Block")
	proto.RegisterType((*BlockRestrictions)(nil), "anytype.model.Block.Restrictions")
	proto.RegisterType((*BlockContent)(nil), "anytype.model.Block.Content")
	proto.RegisterType((*BlockContentLayout)(nil), "anytype.model.Block.Content.Layout")
	proto.RegisterType((*BlockContentLink)(nil), "anytype.model.Block.Content.Link")
	proto.RegisterType((*BlockContentDiv)(nil), "anytype.model.Block.Content.Div")
	proto.RegisterType((*BlockContentBookmark)(nil), "anytype.model.Block.Content.Bookmark")
	proto.RegisterType((*BlockContentIcon)(nil), "anytype.model.Block.Content.Icon")
	proto.RegisterType((*BlockContentFeaturedRelations)(nil), "anytype.model.Block.Content.FeaturedRelations")
	proto.RegisterType((*BlockContentText)(nil), "anytype.model.Block.Content.Text")
	proto.RegisterType((*BlockContentTextMarks)(nil), "anytype.model.Block.Content.Text.Marks")
	proto.RegisterType((*BlockContentTextMark)(nil), "anytype.model.Block.Content.Text.Mark")
	proto.RegisterType((*BlockContentFile)(nil), "anytype.model.Block.Content.File")
	proto.RegisterType((*BlockContentSmartblock)(nil), "anytype.model.Block.Content.Smartblock")
	proto.RegisterType((*BlockContentDataview)(nil), "anytype.model.Block.Content.Dataview")
	proto.RegisterType((*BlockContentDataviewView)(nil), "anytype.model.Block.Content.Dataview.View")
	proto.RegisterType((*BlockContentDataviewRelation)(nil), "anytype.model.Block.Content.Dataview.Relation")
	proto.RegisterType((*BlockContentDataviewSort)(nil), "anytype.model.Block.Content.Dataview.Sort")
	proto.RegisterType((*BlockContentDataviewFilter)(nil), "anytype.model.Block.Content.Dataview.Filter")
	proto.RegisterType((*BlockContentDataviewGroupOrder)(nil), "anytype.model.Block.Content.Dataview.GroupOrder")
	proto.RegisterType((*BlockContentDataviewViewGroup)(nil), "anytype.model.Block.Content.Dataview.ViewGroup")
	proto.RegisterType((*BlockContentDataviewObjectOrder)(nil), "anytype.model.Block.Content.Dataview.ObjectOrder")
	proto.RegisterType((*BlockContentDataviewGroup)(nil), "anytype.model.Block.Content.Dataview.Group")
	proto.RegisterType((*BlockContentDataviewStatus)(nil), "anytype.model.Block.Content.Dataview.Status")
	proto.RegisterType((*BlockContentDataviewTag)(nil), "anytype.model.Block.Content.Dataview.Tag")
	proto.RegisterType((*BlockContentDataviewCheckbox)(nil), "anytype.model.Block.Content.Dataview.Checkbox")
	proto.RegisterType((*BlockContentDataviewDate)(nil), "anytype.model.Block.Content.Dataview.Date")
	proto.RegisterType((*BlockContentRelation)(nil), "anytype.model.Block.Content.Relation")
	proto.RegisterType((*BlockContentLatex)(nil), "anytype.model.Block.Content.Latex")
	proto.RegisterType((*BlockContentTableOfContents)(nil), "anytype.model.Block.Content.TableOfContents")
	proto.RegisterType((*BlockContentTable)(nil), "anytype.model.Block.Content.Table")
	proto.RegisterType((*BlockContentTableColumn)(nil), "anytype.model.Block.Content.TableColumn")
	proto.RegisterType((*BlockContentTableRow)(nil), "anytype.model.Block.Content.TableRow")
	proto.RegisterType((*BlockContentWidget)(nil), "anytype.model.Block.Content.Widget")
	proto.RegisterType((*BlockContentChat)(nil), "anytype.model.Block.Content.Chat")
	proto.RegisterType((*BlockMetaOnly)(nil), "anytype.model.BlockMetaOnly")
	proto.RegisterType((*Range)(nil), "anytype.model.Range")
	proto.RegisterType((*Account)(nil), "anytype.model.Account")
	proto.RegisterType((*AccountConfig)(nil), "anytype.model.Account.Config")
	proto.RegisterType((*AccountStatus)(nil), "anytype.model.Account.Status")
	proto.RegisterType((*AccountInfo)(nil), "anytype.model.Account.Info")
	proto.RegisterType((*AccountAuth)(nil), "anytype.model.Account.Auth")
	proto.RegisterType((*AccountAuthAppInfo)(nil), "anytype.model.Account.Auth.AppInfo")
	proto.RegisterType((*LinkPreview)(nil), "anytype.model.LinkPreview")
	proto.RegisterType((*Restrictions)(nil), "anytype.model.Restrictions")
	proto.RegisterType((*RestrictionsDataviewRestrictions)(nil), "anytype.model.Restrictions.DataviewRestrictions")
	proto.RegisterType((*Object)(nil), "anytype.model.Object")
	proto.RegisterType((*ObjectChangePayload)(nil), "anytype.model.Object.ChangePayload")
	proto.RegisterType((*SpaceObjectHeader)(nil), "anytype.model.SpaceObjectHeader")
	proto.RegisterType((*ObjectType)(nil), "anytype.model.ObjectType")
	proto.RegisterType((*Layout)(nil), "anytype.model.Layout")
	proto.RegisterType((*RelationWithValue)(nil), "anytype.model.RelationWithValue")
	proto.RegisterType((*Relation)(nil), "anytype.model.Relation")
	proto.RegisterType((*RelationOption)(nil), "anytype.model.Relation.Option")
	proto.RegisterType((*RelationLink)(nil), "anytype.model.RelationLink")
	proto.RegisterType((*Relations)(nil), "anytype.model.Relations")
	proto.RegisterType((*RelationOptions)(nil), "anytype.model.RelationOptions")
	proto.RegisterType((*InternalFlag)(nil), "anytype.model.InternalFlag")
	proto.RegisterType((*ObjectView)(nil), "anytype.model.ObjectView")
	proto.RegisterType((*ObjectViewDetailsSet)(nil), "anytype.model.ObjectView.DetailsSet")
	proto.RegisterType((*ObjectViewRelationWithValuePerObject)(nil), "anytype.model.ObjectView.RelationWithValuePerObject")
	proto.RegisterType((*ObjectViewHistorySize)(nil), "anytype.model.ObjectView.HistorySize")
	proto.RegisterType((*ObjectViewBlockParticipant)(nil), "anytype.model.ObjectView.BlockParticipant")
	proto.RegisterType((*ParticipantPermissionChange)(nil), "anytype.model.ParticipantPermissionChange")
	proto.RegisterType((*Metadata)(nil), "anytype.model.Metadata")
	proto.RegisterType((*MetadataPayload)(nil), "anytype.model.Metadata.Payload")
	proto.RegisterType((*MetadataPayloadIdentityPayload)(nil), "anytype.model.Metadata.Payload.IdentityPayload")
	proto.RegisterType((*Notification)(nil), "anytype.model.Notification")
	proto.RegisterType((*NotificationImport)(nil), "anytype.model.Notification.Import")
	proto.RegisterType((*NotificationExport)(nil), "anytype.model.Notification.Export")
	proto.RegisterType((*NotificationGalleryImport)(nil), "anytype.model.Notification.GalleryImport")
	proto.RegisterType((*NotificationRequestToJoin)(nil), "anytype.model.Notification.RequestToJoin")
	proto.RegisterType((*NotificationTest)(nil), "anytype.model.Notification.Test")
	proto.RegisterType((*NotificationParticipantRequestApproved)(nil), "anytype.model.Notification.ParticipantRequestApproved")
	proto.RegisterType((*NotificationRequestToLeave)(nil), "anytype.model.Notification.RequestToLeave")
	proto.RegisterType((*NotificationParticipantRemove)(nil), "anytype.model.Notification.ParticipantRemove")
	proto.RegisterType((*NotificationParticipantRequestDecline)(nil), "anytype.model.Notification.ParticipantRequestDecline")
	proto.RegisterType((*NotificationParticipantPermissionsChange)(nil), "anytype.model.Notification.ParticipantPermissionsChange")
	proto.RegisterType((*Export)(nil), "anytype.model.Export")
	proto.RegisterType((*Import)(nil), "anytype.model.Import")
	proto.RegisterType((*Invite)(nil), "anytype.model.Invite")
	proto.RegisterType((*InvitePayload)(nil), "anytype.model.InvitePayload")
	proto.RegisterType((*IdentityProfile)(nil), "anytype.model.IdentityProfile")
	proto.RegisterType((*FileInfo)(nil), "anytype.model.FileInfo")
	proto.RegisterType((*FileEncryptionKey)(nil), "anytype.model.FileEncryptionKey")
	proto.RegisterType((*ManifestInfo)(nil), "anytype.model.ManifestInfo")
	proto.RegisterType((*Membership)(nil), "anytype.model.Membership")
	proto.RegisterType((*MembershipTierData)(nil), "anytype.model.MembershipTierData")
	proto.RegisterType((*Detail)(nil), "anytype.model.Detail")
	proto.RegisterType((*DeviceInfo)(nil), "anytype.model.DeviceInfo")
	proto.RegisterType((*ChatState)(nil), "anytype.model.ChatState")
	proto.RegisterType((*ChatStateUnreadState)(nil), "anytype.model.ChatState.UnreadState")
	proto.RegisterType((*ChatMessage)(nil), "anytype.model.ChatMessage")
	proto.RegisterType((*ChatMessageMessageContent)(nil), "anytype.model.ChatMessage.MessageContent")
	proto.RegisterType((*ChatMessageAttachment)(nil), "anytype.model.ChatMessage.Attachment")
	proto.RegisterType((*ChatMessageReactions)(nil), "anytype.model.ChatMessage.Reactions")
	proto.RegisterMapType((map[string]*ChatMessageReactionsIdentityList)(nil), "anytype.model.ChatMessage.Reactions.ReactionsEntry")
	proto.RegisterType((*ChatMessageReactionsIdentityList)(nil), "anytype.model.ChatMessage.Reactions.IdentityList")
}

func init() {
	proto.RegisterFile("pkg/lib/pb/model/protos/models.proto", fileDescriptor_98a910b73321e591)
}

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

func (m *SmartBlockSnapshotBase) 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 *SmartBlockSnapshotBase) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SmartBlockSnapshotBase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FileInfo != nil {
		{
			size, err := m.FileInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.OriginalCreatedTimestamp != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.OriginalCreatedTimestamp))
		i--
		dAtA[i] = 0x50
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.RemovedCollectionKeys) > 0 {
		for iNdEx := len(m.RemovedCollectionKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RemovedCollectionKeys[iNdEx])
			copy(dAtA[i:], m.RemovedCollectionKeys[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.RemovedCollectionKeys[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Collections != nil {
		{
			size, err := m.Collections.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.ObjectTypes) > 0 {
		for iNdEx := len(m.ObjectTypes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectTypes[iNdEx])
			copy(dAtA[i:], m.ObjectTypes[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.ObjectTypes[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.ExtraRelations) > 0 {
		for iNdEx := len(m.ExtraRelations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ExtraRelations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.FileKeys != nil {
		{
			size, err := m.FileKeys.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Search) 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 *Search) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Search) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *SearchResult) 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 *SearchResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SearchResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Meta) > 0 {
		for iNdEx := len(m.Meta) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Meta[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ObjectId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SearchMeta) 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 *SearchMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SearchMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RelationDetails != nil {
		{
			size, err := m.RelationDetails.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.HighlightRanges) > 0 {
		for iNdEx := len(m.HighlightRanges) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HighlightRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Highlight) > 0 {
		i -= len(m.Highlight)
		copy(dAtA[i:], m.Highlight)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Highlight)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Block) 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 *Block) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Block) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Content != nil {
		{
			size := m.Content.Size()
			i -= size
			if _, err := m.Content.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.VerticalAlign != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.VerticalAlign))
		i--
		dAtA[i] = 0x38
	}
	if m.Align != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Align))
		i--
		dAtA[i] = 0x30
	}
	if len(m.BackgroundColor) > 0 {
		i -= len(m.BackgroundColor)
		copy(dAtA[i:], m.BackgroundColor)
		i = encodeVarintModels(dAtA, i, uint64(len(m.BackgroundColor)))
		i--
		dAtA[i] = 0x2a
	}
	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 = encodeVarintModels(dAtA, i, uint64(len(m.ChildrenIds[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Restrictions != nil {
		{
			size, err := m.Restrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BlockContentOfSmartblock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Smartblock != nil {
		{
			size, err := m.Smartblock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Text != nil {
		{
			size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfLayout) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfLayout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Layout != nil {
		{
			size, err := m.Layout.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Div != nil {
		{
			size, err := m.Div.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Bookmark != nil {
		{
			size, err := m.Bookmark.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfIcon) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfIcon) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Icon != nil {
		{
			size, err := m.Icon.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Link != nil {
		{
			size, err := m.Link.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfDataview) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfDataview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Dataview != nil {
		{
			size, err := m.Dataview.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfFeaturedRelations) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfFeaturedRelations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FeaturedRelations != nil {
		{
			size, err := m.FeaturedRelations.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfLatex) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfLatex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Latex != nil {
		{
			size, err := m.Latex.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfTableOfContents) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfTableOfContents) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TableOfContents != nil {
		{
			size, err := m.TableOfContents.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xca
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfTable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Table != nil {
		{
			size, err := m.Table.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfTableColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfTableColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TableColumn != nil {
		{
			size, err := m.TableColumn.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xda
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfTableRow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfTableRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TableRow != nil {
		{
			size, err := m.TableRow.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe2
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfWidget) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfWidget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Widget != nil {
		{
			size, err := m.Widget.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xea
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentOfChat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentOfChat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Chat != nil {
		{
			size, err := m.Chat.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf2
	}
	return len(dAtA) - i, nil
}
func (m *BlockRestrictions) 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 *BlockRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DropOn {
		i--
		if m.DropOn {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Drag {
		i--
		if m.Drag {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Remove {
		i--
		if m.Remove {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Edit {
		i--
		if m.Edit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Read {
		i--
		if m.Read {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContent) 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 *BlockContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentLayout) 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 *BlockContentLayout) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentLayout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentLink) 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 *BlockContentLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Relations[iNdEx])
			copy(dAtA[i:], m.Relations[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.Relations[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Description != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Description))
		i--
		dAtA[i] = 0x30
	}
	if m.CardStyle != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.CardStyle))
		i--
		dAtA[i] = 0x28
	}
	if m.IconSize != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.IconSize))
		i--
		dAtA[i] = 0x20
	}
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Style != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x10
	}
	if len(m.TargetBlockId) > 0 {
		i -= len(m.TargetBlockId)
		copy(dAtA[i:], m.TargetBlockId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.TargetBlockId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDiv) 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 *BlockContentDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentBookmark) 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 *BlockContentBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x40
	}
	if len(m.TargetObjectId) > 0 {
		i -= len(m.TargetObjectId)
		copy(dAtA[i:], m.TargetObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.TargetObjectId)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x30
	}
	if len(m.FaviconHash) > 0 {
		i -= len(m.FaviconHash)
		copy(dAtA[i:], m.FaviconHash)
		i = encodeVarintModels(dAtA, i, uint64(len(m.FaviconHash)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ImageHash) > 0 {
		i -= len(m.ImageHash)
		copy(dAtA[i:], m.ImageHash)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ImageHash)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentIcon) 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 *BlockContentIcon) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentIcon) 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 = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentFeaturedRelations) 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 *BlockContentFeaturedRelations) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentFeaturedRelations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentText) 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 *BlockContentText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IconImage) > 0 {
		i -= len(m.IconImage)
		copy(dAtA[i:], m.IconImage)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IconImage)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.IconEmoji) > 0 {
		i -= len(m.IconEmoji)
		copy(dAtA[i:], m.IconEmoji)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IconEmoji)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Checked {
		i--
		if m.Checked {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Marks != nil {
		{
			size, err := m.Marks.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Style != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Text) > 0 {
		i -= len(m.Text)
		copy(dAtA[i:], m.Text)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Text)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentTextMarks) 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 *BlockContentTextMarks) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentTextMarks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Marks) > 0 {
		for iNdEx := len(m.Marks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Marks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentTextMark) 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 *BlockContentTextMark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentTextMark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Param) > 0 {
		i -= len(m.Param)
		copy(dAtA[i:], m.Param)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Param)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.Range != nil {
		{
			size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentFile) 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 *BlockContentFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentFile) 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 = encodeVarintModels(dAtA, i, uint64(len(m.TargetObjectId)))
		i--
		dAtA[i] = 0x4a
	}
	if m.Style != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x40
	}
	if m.State != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x38
	}
	if m.AddedAt != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.AddedAt))
		i--
		dAtA[i] = 0x30
	}
	if m.Size_ != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Mime) > 0 {
		i -= len(m.Mime)
		copy(dAtA[i:], m.Mime)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Mime)))
		i--
		dAtA[i] = 0x22
	}
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentSmartblock) 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 *BlockContentSmartblock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentSmartblock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentDataview) 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 *BlockContentDataview) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsCollection {
		i--
		if m.IsCollection {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if len(m.ObjectOrders) > 0 {
		for iNdEx := len(m.ObjectOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ObjectOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.GroupOrders) > 0 {
		for iNdEx := len(m.GroupOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.GroupOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.TargetObjectId) > 0 {
		i -= len(m.TargetObjectId)
		copy(dAtA[i:], m.TargetObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.TargetObjectId)))
		i--
		dAtA[i] = 0x32
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.ActiveView) > 0 {
		i -= len(m.ActiveView)
		copy(dAtA[i:], m.ActiveView)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ActiveView)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Views) > 0 {
		for iNdEx := len(m.Views) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Views[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	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 = encodeVarintModels(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewView) 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 *BlockContentDataviewView) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewView) 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 = encodeVarintModels(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 = encodeVarintModels(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 = encodeVarintModels(dAtA, i, uint64(len(m.DefaultTemplateId)))
		i--
		dAtA[i] = 0x72
	}
	if m.PageLimit != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.PageLimit))
		i--
		dAtA[i] = 0x68
	}
	if m.GroupBackgroundColors {
		i--
		if m.GroupBackgroundColors {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if len(m.GroupRelationKey) > 0 {
		i -= len(m.GroupRelationKey)
		copy(dAtA[i:], m.GroupRelationKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.GroupRelationKey)))
		i--
		dAtA[i] = 0x5a
	}
	if m.CoverFit {
		i--
		if m.CoverFit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.CardSize != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.CardSize))
		i--
		dAtA[i] = 0x48
	}
	if m.HideIcon {
		i--
		if m.HideIcon {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.CoverRelationKey) > 0 {
		i -= len(m.CoverRelationKey)
		copy(dAtA[i:], m.CoverRelationKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.CoverRelationKey)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Filters) > 0 {
		for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Filters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Sorts) > 0 {
		for iNdEx := len(m.Sorts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sorts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewRelation) 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 *BlockContentDataviewRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Align != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Align))
		i--
		dAtA[i] = 0x48
	}
	if m.Formula != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Formula))
		i--
		dAtA[i] = 0x40
	}
	if m.DateFormat != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.DateFormat))
		i--
		dAtA[i] = 0x38
	}
	if m.TimeFormat != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.TimeFormat))
		i--
		dAtA[i] = 0x30
	}
	if m.DateIncludeTime {
		i--
		if m.DateIncludeTime {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Width != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x18
	}
	if m.IsVisible {
		i--
		if m.IsVisible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewSort) 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 *BlockContentDataviewSort) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewSort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoCollate {
		i--
		if m.NoCollate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.EmptyPlacement != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.EmptyPlacement))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x32
	}
	if m.IncludeTime {
		i--
		if m.IncludeTime {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Format != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Format))
		i--
		dAtA[i] = 0x20
	}
	if len(m.CustomOrder) > 0 {
		for iNdEx := len(m.CustomOrder) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CustomOrder[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewFilter) 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 *BlockContentDataviewFilter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NestedFilters) > 0 {
		for iNdEx := len(m.NestedFilters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NestedFilters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x4a
	}
	if m.IncludeTime {
		i--
		if m.IncludeTime {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.Format != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Format))
		i--
		dAtA[i] = 0x38
	}
	if m.QuickOption != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.QuickOption))
		i--
		dAtA[i] = 0x30
	}
	if len(m.RelationProperty) > 0 {
		i -= len(m.RelationProperty)
		copy(dAtA[i:], m.RelationProperty)
		i = encodeVarintModels(dAtA, i, uint64(len(m.RelationProperty)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Condition != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Condition))
		i--
		dAtA[i] = 0x18
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if m.Operator != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Operator))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewGroupOrder) 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 *BlockContentDataviewGroupOrder) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewGroupOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ViewGroups) > 0 {
		for iNdEx := len(m.ViewGroups) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ViewGroups[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewViewGroup) 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 *BlockContentDataviewViewGroup) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewViewGroup) 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 = encodeVarintModels(dAtA, i, uint64(len(m.BackgroundColor)))
		i--
		dAtA[i] = 0x22
	}
	if m.Hidden {
		i--
		if m.Hidden {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Index != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if len(m.GroupId) > 0 {
		i -= len(m.GroupId)
		copy(dAtA[i:], m.GroupId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.GroupId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewObjectOrder) 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 *BlockContentDataviewObjectOrder) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewObjectOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectIds) > 0 {
		for iNdEx := len(m.ObjectIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectIds[iNdEx])
			copy(dAtA[i:], m.ObjectIds[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.ObjectIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.GroupId) > 0 {
		i -= len(m.GroupId)
		copy(dAtA[i:], m.GroupId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.GroupId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewGroup) 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 *BlockContentDataviewGroup) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewGroup) 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.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BlockContentDataviewGroupValueOfStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentDataviewGroupValueOfTag) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BlockContentDataviewGroupValueOfDate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Date != nil {
		{
			size, err := m.Date.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *BlockContentDataviewStatus) 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 *BlockContentDataviewStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewStatus) 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 = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewTag) 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 *BlockContentDataviewTag) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewTag) 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 = encodeVarintModels(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewCheckbox) 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 *BlockContentDataviewCheckbox) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewCheckbox) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Checked {
		i--
		if m.Checked {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentDataviewDate) 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 *BlockContentDataviewDate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentDataviewDate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentRelation) 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 *BlockContentRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *BlockContentLatex) 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 *BlockContentLatex) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentLatex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Processor != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Processor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Text) > 0 {
		i -= len(m.Text)
		copy(dAtA[i:], m.Text)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Text)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentTableOfContents) 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 *BlockContentTableOfContents) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentTableOfContents) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentTable) 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 *BlockContentTable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentTableColumn) 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 *BlockContentTableColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentTableColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockContentTableRow) 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 *BlockContentTableRow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentTableRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsHeader {
		i--
		if m.IsHeader {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentWidget) 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 *BlockContentWidget) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentWidget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AutoAdded {
		i--
		if m.AutoAdded {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Limit != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x10
	}
	if m.Layout != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Layout))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockContentChat) 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 *BlockContentChat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockContentChat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *BlockMetaOnly) 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 *BlockMetaOnly) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockMetaOnly) 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 = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Range) 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 *Range) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Range) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.To != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.To))
		i--
		dAtA[i] = 0x10
	}
	if m.From != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.From))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Account) 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 *Account) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Account) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Info != nil {
		{
			size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AccountConfig) 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 *AccountConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Extra != nil {
		{
			size, err := m.Extra.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa2
	}
	if m.EnableSpaces {
		i--
		if m.EnableSpaces {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.EnablePrereleaseChannel {
		i--
		if m.EnablePrereleaseChannel {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.EnableDebug {
		i--
		if m.EnableDebug {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.EnableDataview {
		i--
		if m.EnableDataview {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AccountStatus) 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 *AccountStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DeletionDate != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.DeletionDate))
		i--
		dAtA[i] = 0x10
	}
	if m.StatusType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.StatusType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AccountInfo) 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 *AccountInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EthereumAddress) > 0 {
		i -= len(m.EthereumAddress)
		copy(dAtA[i:], m.EthereumAddress)
		i = encodeVarintModels(dAtA, i, uint64(len(m.EthereumAddress)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xda
	}
	if len(m.NetworkId) > 0 {
		i -= len(m.NetworkId)
		copy(dAtA[i:], m.NetworkId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.NetworkId)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xd2
	}
	if len(m.AnalyticsId) > 0 {
		i -= len(m.AnalyticsId)
		copy(dAtA[i:], m.AnalyticsId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AnalyticsId)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xca
	}
	if len(m.TimeZone) > 0 {
		i -= len(m.TimeZone)
		copy(dAtA[i:], m.TimeZone)
		i = encodeVarintModels(dAtA, i, uint64(len(m.TimeZone)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xc2
	}
	if len(m.LocalStoragePath) > 0 {
		i -= len(m.LocalStoragePath)
		copy(dAtA[i:], m.LocalStoragePath)
		i = encodeVarintModels(dAtA, i, uint64(len(m.LocalStoragePath)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xba
	}
	if len(m.GatewayUrl) > 0 {
		i -= len(m.GatewayUrl)
		copy(dAtA[i:], m.GatewayUrl)
		i = encodeVarintModels(dAtA, i, uint64(len(m.GatewayUrl)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xaa
	}
	if len(m.SpaceChatId) > 0 {
		i -= len(m.SpaceChatId)
		copy(dAtA[i:], m.SpaceChatId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceChatId)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.WorkspaceObjectId) > 0 {
		i -= len(m.WorkspaceObjectId)
		copy(dAtA[i:], m.WorkspaceObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.WorkspaceObjectId)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.TechSpaceId) > 0 {
		i -= len(m.TechSpaceId)
		copy(dAtA[i:], m.TechSpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.TechSpaceId)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.SpaceViewId) > 0 {
		i -= len(m.SpaceViewId)
		copy(dAtA[i:], m.SpaceViewId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceViewId)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.MarketplaceWorkspaceId) > 0 {
		i -= len(m.MarketplaceWorkspaceId)
		copy(dAtA[i:], m.MarketplaceWorkspaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.MarketplaceWorkspaceId)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.WidgetsId) > 0 {
		i -= len(m.WidgetsId)
		copy(dAtA[i:], m.WidgetsId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.WidgetsId)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.AccountSpaceId) > 0 {
		i -= len(m.AccountSpaceId)
		copy(dAtA[i:], m.AccountSpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AccountSpaceId)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.DeviceId) > 0 {
		i -= len(m.DeviceId)
		copy(dAtA[i:], m.DeviceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.DeviceId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.ProfileObjectId) > 0 {
		i -= len(m.ProfileObjectId)
		copy(dAtA[i:], m.ProfileObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ProfileObjectId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ArchiveObjectId) > 0 {
		i -= len(m.ArchiveObjectId)
		copy(dAtA[i:], m.ArchiveObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ArchiveObjectId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.HomeObjectId) > 0 {
		i -= len(m.HomeObjectId)
		copy(dAtA[i:], m.HomeObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.HomeObjectId)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *AccountAuth) 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 *AccountAuth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountAuth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AccountAuthAppInfo) 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 *AccountAuthAppInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountAuthAppInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsActive {
		i--
		if m.IsActive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.Scope != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Scope))
		i--
		dAtA[i] = 0x38
	}
	if m.ExpireAt != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ExpireAt))
		i--
		dAtA[i] = 0x30
	}
	if m.CreatedAt != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x28
	}
	if len(m.AppKey) > 0 {
		i -= len(m.AppKey)
		copy(dAtA[i:], m.AppKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AppKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.AppName) > 0 {
		i -= len(m.AppName)
		copy(dAtA[i:], m.AppName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AppName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AppHash) > 0 {
		i -= len(m.AppHash)
		copy(dAtA[i:], m.AppHash)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AppHash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LinkPreview) 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 *LinkPreview) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LinkPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x30
	}
	if len(m.FaviconUrl) > 0 {
		i -= len(m.FaviconUrl)
		copy(dAtA[i:], m.FaviconUrl)
		i = encodeVarintModels(dAtA, i, uint64(len(m.FaviconUrl)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ImageUrl) > 0 {
		i -= len(m.ImageUrl)
		copy(dAtA[i:], m.ImageUrl)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ImageUrl)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Restrictions) 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 *Restrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Restrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Dataview) > 0 {
		for iNdEx := len(m.Dataview) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Dataview[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Object) > 0 {
		dAtA41 := make([]byte, len(m.Object)*10)
		var j40 int
		for _, num := range m.Object {
			for num >= 1<<7 {
				dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j40++
			}
			dAtA41[j40] = uint8(num)
			j40++
		}
		i -= j40
		copy(dAtA[i:], dAtA41[:j40])
		i = encodeVarintModels(dAtA, i, uint64(j40))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RestrictionsDataviewRestrictions) 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 *RestrictionsDataviewRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RestrictionsDataviewRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Restrictions) > 0 {
		dAtA43 := make([]byte, len(m.Restrictions)*10)
		var j42 int
		for _, num := range m.Restrictions {
			for num >= 1<<7 {
				dAtA43[j42] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j42++
			}
			dAtA43[j42] = uint8(num)
			j42++
		}
		i -= j42
		copy(dAtA[i:], dAtA43[:j42])
		i = encodeVarintModels(dAtA, i, uint64(j42))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Object) 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 *Object) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Object) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ObjectChangePayload) 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 *ObjectChangePayload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectChangePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x12
	}
	if m.SmartBlockType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.SmartBlockType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SpaceObjectHeader) 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 *SpaceObjectHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SpaceObjectHeader) 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 = encodeVarintModels(dAtA, i, uint64(len(m.SpaceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ObjectType) 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 *ObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PluralName) > 0 {
		i -= len(m.PluralName)
		copy(dAtA[i:], m.PluralName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.PluralName)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.IconName) > 0 {
		i -= len(m.IconName)
		copy(dAtA[i:], m.IconName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IconName)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.IconColor != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.IconColor))
		i--
		dAtA[i] = 0x78
	}
	if m.RestrictObjectCreation {
		i--
		if m.RestrictObjectCreation {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if m.Revision != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x68
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x62
	}
	if m.InstalledByDefault {
		i--
		if m.InstalledByDefault {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.Readonly {
		i--
		if m.Readonly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.IsArchived {
		i--
		if m.IsArchived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if len(m.Types) > 0 {
		dAtA45 := make([]byte, len(m.Types)*10)
		var j44 int
		for _, num := range m.Types {
			for num >= 1<<7 {
				dAtA45[j44] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j44++
			}
			dAtA45[j44] = uint8(num)
			j44++
		}
		i -= j44
		copy(dAtA[i:], dAtA45[:j44])
		i = encodeVarintModels(dAtA, i, uint64(j44))
		i--
		dAtA[i] = 0x42
	}
	if m.Hidden {
		i--
		if m.Hidden {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.IconEmoji) > 0 {
		i -= len(m.IconEmoji)
		copy(dAtA[i:], m.IconEmoji)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IconEmoji)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Layout != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Layout))
		i--
		dAtA[i] = 0x20
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Layout) 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 *Layout) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Layout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RequiredRelations) > 0 {
		for iNdEx := len(m.RequiredRelations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RequiredRelations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RelationWithValue) 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 *RelationWithValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RelationWithValue) 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 = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Relation) 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 *Relation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Relation) 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 = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa2
	}
	if m.IncludeTime {
		i--
		if m.IncludeTime {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if m.Revision != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb0
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if m.Scope != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Scope))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if m.ReadOnlyRelation {
		i--
		if m.ReadOnlyRelation {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x78
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x72
	}
	if m.MaxCount != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.MaxCount))
		i--
		dAtA[i] = 0x68
	}
	if len(m.SelectDict) > 0 {
		for iNdEx := len(m.SelectDict) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SelectDict[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.ObjectTypes) > 0 {
		for iNdEx := len(m.ObjectTypes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectTypes[iNdEx])
			copy(dAtA[i:], m.ObjectTypes[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.ObjectTypes[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.Multi {
		i--
		if m.Multi {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.ReadOnly {
		i--
		if m.ReadOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Hidden {
		i--
		if m.Hidden {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.DataSource != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.DataSource))
		i--
		dAtA[i] = 0x28
	}
	if m.DefaultValue != nil {
		{
			size, err := m.DefaultValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Format != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Format))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RelationOption) 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 *RelationOption) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RelationOption) 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 = encodeVarintModels(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Text) > 0 {
		i -= len(m.Text)
		copy(dAtA[i:], m.Text)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Text)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RelationLink) 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 *RelationLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RelationLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Format != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Format))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Relations) 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 *Relations) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Relations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RelationOptions) 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 *RelationOptions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RelationOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Options) > 0 {
		for iNdEx := len(m.Options) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Options[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *InternalFlag) 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 *InternalFlag) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InternalFlag) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ObjectView) 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 *ObjectView) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockParticipants) > 0 {
		for iNdEx := len(m.BlockParticipants) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockParticipants[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if m.History != nil {
		{
			size, err := m.History.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Restrictions != nil {
		{
			size, err := m.Restrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x20
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	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 = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.RootId) > 0 {
		i -= len(m.RootId)
		copy(dAtA[i:], m.RootId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.RootId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ObjectViewDetailsSet) 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 *ObjectViewDetailsSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectViewDetailsSet) 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 = encodeVarintModels(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 = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ObjectViewRelationWithValuePerObject) 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 *ObjectViewRelationWithValuePerObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectViewRelationWithValuePerObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ObjectId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ObjectViewHistorySize) 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 *ObjectViewHistorySize) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectViewHistorySize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Redo != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Redo))
		i--
		dAtA[i] = 0x10
	}
	if m.Undo != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Undo))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ObjectViewBlockParticipant) 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 *ObjectViewBlockParticipant) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ParticipantPermissionChange) 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 *ParticipantPermissionChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParticipantPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Perms != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Perms))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Metadata) 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 *Metadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Payload != nil {
		{
			size := m.Payload.Size()
			i -= size
			if _, err := m.Payload.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *MetadataPayloadOfIdentity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Identity != nil {
		{
			size, err := m.Identity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *MetadataPayload) 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 *MetadataPayload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataPayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MetadataPayloadIdentityPayload) 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 *MetadataPayloadIdentityPayload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Notification) 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 *Notification) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Notification) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Payload != nil {
		{
			size := m.Payload.Size()
			i -= size
			if _, err := m.Payload.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.AclHeadId) > 0 {
		i -= len(m.AclHeadId)
		copy(dAtA[i:], m.AclHeadId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AclHeadId)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.Space) > 0 {
		i -= len(m.Space)
		copy(dAtA[i:], m.Space)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Space)))
		i--
		dAtA[i] = 0x3a
	}
	if m.IsLocal {
		i--
		if m.IsLocal {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Status != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if m.CreateTime != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.CreateTime))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NotificationPayloadOfImport) 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 = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfExport) 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 = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfGalleryImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfGalleryImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GalleryImport != nil {
		{
			size, err := m.GalleryImport.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfRequestToJoin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfRequestToJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RequestToJoin != nil {
		{
			size, err := m.RequestToJoin.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfTest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfTest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Test != nil {
		{
			size, err := m.Test.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfParticipantRequestApproved) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfParticipantRequestApproved) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ParticipantRequestApproved != nil {
		{
			size, err := m.ParticipantRequestApproved.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfRequestToLeave) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfRequestToLeave) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RequestToLeave != nil {
		{
			size, err := m.RequestToLeave.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfParticipantRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfParticipantRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ParticipantRemove != nil {
		{
			size, err := m.ParticipantRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfParticipantRequestDecline) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfParticipantRequestDecline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ParticipantRequestDecline != nil {
		{
			size, err := m.ParticipantRequestDecline.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *NotificationPayloadOfParticipantPermissionsChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationPayloadOfParticipantPermissionsChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ParticipantPermissionsChange != nil {
		{
			size, err := m.ParticipantPermissionsChange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}
func (m *NotificationImport) 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 *NotificationImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x22
	}
	if m.ImportType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ImportType))
		i--
		dAtA[i] = 0x18
	}
	if m.ErrorCode != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ErrorCode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ProcessId) > 0 {
		i -= len(m.ProcessId)
		copy(dAtA[i:], m.ProcessId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ProcessId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationExport) 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 *NotificationExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExportType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ExportType))
		i--
		dAtA[i] = 0x18
	}
	if m.ErrorCode != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ErrorCode))
		i--
		dAtA[i] = 0x10
	}
	return len(dAtA) - i, nil
}

func (m *NotificationGalleryImport) 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 *NotificationGalleryImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationGalleryImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ErrorCode != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ErrorCode))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ProcessId) > 0 {
		i -= len(m.ProcessId)
		copy(dAtA[i:], m.ProcessId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ProcessId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationRequestToJoin) 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 *NotificationRequestToJoin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationRequestToJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.IdentityIcon) > 0 {
		i -= len(m.IdentityIcon)
		copy(dAtA[i:], m.IdentityIcon)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityIcon)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.IdentityName) > 0 {
		i -= len(m.IdentityName)
		copy(dAtA[i:], m.IdentityName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationTest) 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 *NotificationTest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationTest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *NotificationParticipantRequestApproved) 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 *NotificationParticipantRequestApproved) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationParticipantRequestApproved) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Permissions != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x10
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationRequestToLeave) 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 *NotificationRequestToLeave) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationRequestToLeave) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.IdentityIcon) > 0 {
		i -= len(m.IdentityIcon)
		copy(dAtA[i:], m.IdentityIcon)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityIcon)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.IdentityName) > 0 {
		i -= len(m.IdentityName)
		copy(dAtA[i:], m.IdentityName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationParticipantRemove) 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 *NotificationParticipantRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationParticipantRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.IdentityIcon) > 0 {
		i -= len(m.IdentityIcon)
		copy(dAtA[i:], m.IdentityIcon)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityIcon)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.IdentityName) > 0 {
		i -= len(m.IdentityName)
		copy(dAtA[i:], m.IdentityName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IdentityName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationParticipantRequestDecline) 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 *NotificationParticipantRequestDecline) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationParticipantRequestDecline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NotificationParticipantPermissionsChange) 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 *NotificationParticipantPermissionsChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotificationParticipantPermissionsChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Permissions != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x10
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Export) 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 *Export) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Export) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *Import) 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 *Import) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Import) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *Invite) 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 *Invite) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *InvitePayload) 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 *InvitePayload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InvitePayload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.GuestKey) > 0 {
		i -= len(m.GuestKey)
		copy(dAtA[i:], m.GuestKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.GuestKey)))
		i--
		dAtA[i] = 0x4a
	}
	if m.InviteType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.InviteType))
		i--
		dAtA[i] = 0x40
	}
	if len(m.SpaceIconEncryptionKeys) > 0 {
		for iNdEx := len(m.SpaceIconEncryptionKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SpaceIconEncryptionKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.SpaceIconCid) > 0 {
		i -= len(m.SpaceIconCid)
		copy(dAtA[i:], m.SpaceIconCid)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceIconCid)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.SpaceName) > 0 {
		i -= len(m.SpaceName)
		copy(dAtA[i:], m.SpaceName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.AclKey) > 0 {
		i -= len(m.AclKey)
		copy(dAtA[i:], m.AclKey)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AclKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.CreatorName) > 0 {
		i -= len(m.CreatorName)
		copy(dAtA[i:], m.CreatorName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.CreatorName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.CreatorIdentity) > 0 {
		i -= len(m.CreatorIdentity)
		copy(dAtA[i:], m.CreatorIdentity)
		i = encodeVarintModels(dAtA, i, uint64(len(m.CreatorIdentity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IdentityProfile) 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 *IdentityProfile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IdentityProfile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.GlobalName) > 0 {
		i -= len(m.GlobalName)
		copy(dAtA[i:], m.GlobalName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.GlobalName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.IconEncryptionKeys) > 0 {
		for iNdEx := len(m.IconEncryptionKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.IconEncryptionKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.IconCid) > 0 {
		i -= len(m.IconCid)
		copy(dAtA[i:], m.IconCid)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IconCid)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileInfo) 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 *FileInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FileInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EncryptionKeys) > 0 {
		for iNdEx := len(m.EncryptionKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EncryptionKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.FileId) > 0 {
		i -= len(m.FileId)
		copy(dAtA[i:], m.FileId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.FileId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FileEncryptionKey) 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 *FileEncryptionKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ManifestInfo) 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 *ManifestInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ManifestInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Language) > 0 {
		i -= len(m.Language)
		copy(dAtA[i:], m.Language)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Language)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.Categories) > 0 {
		for iNdEx := len(m.Categories) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Categories[iNdEx])
			copy(dAtA[i:], m.Categories[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.Categories[iNdEx])))
			i--
			dAtA[i] = 0x5a
		}
	}
	if m.FileSize != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.FileSize))
		i--
		dAtA[i] = 0x50
	}
	if len(m.DownloadLink) > 0 {
		i -= len(m.DownloadLink)
		copy(dAtA[i:], m.DownloadLink)
		i = encodeVarintModels(dAtA, i, uint64(len(m.DownloadLink)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Screenshots) > 0 {
		for iNdEx := len(m.Screenshots) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Screenshots[iNdEx])
			copy(dAtA[i:], m.Screenshots[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.Screenshots[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.License) > 0 {
		i -= len(m.License)
		copy(dAtA[i:], m.License)
		i = encodeVarintModels(dAtA, i, uint64(len(m.License)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Author) > 0 {
		i -= len(m.Author)
		copy(dAtA[i:], m.Author)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Author)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Schema) > 0 {
		i -= len(m.Schema)
		copy(dAtA[i:], m.Schema)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Schema)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Membership) 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 *Membership) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Membership) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SubscribeToNewsletter {
		i--
		if m.SubscribeToNewsletter {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if len(m.UserEmail) > 0 {
		i -= len(m.UserEmail)
		copy(dAtA[i:], m.UserEmail)
		i = encodeVarintModels(dAtA, i, uint64(len(m.UserEmail)))
		i--
		dAtA[i] = 0x4a
	}
	if m.NsNameType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.NsNameType))
		i--
		dAtA[i] = 0x40
	}
	if len(m.NsName) > 0 {
		i -= len(m.NsName)
		copy(dAtA[i:], m.NsName)
		i = encodeVarintModels(dAtA, i, uint64(len(m.NsName)))
		i--
		dAtA[i] = 0x3a
	}
	if m.PaymentMethod != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.PaymentMethod))
		i--
		dAtA[i] = 0x30
	}
	if m.IsAutoRenew {
		i--
		if m.IsAutoRenew {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.DateEnds != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.DateEnds))
		i--
		dAtA[i] = 0x20
	}
	if m.DateStarted != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.DateStarted))
		i--
		dAtA[i] = 0x18
	}
	if m.Status != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.Tier != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Tier))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MembershipTierData) 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 *MembershipTierData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MembershipTierData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Offer) > 0 {
		i -= len(m.Offer)
		copy(dAtA[i:], m.Offer)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Offer)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if len(m.AndroidManageUrl) > 0 {
		i -= len(m.AndroidManageUrl)
		copy(dAtA[i:], m.AndroidManageUrl)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AndroidManageUrl)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.AndroidProductId) > 0 {
		i -= len(m.AndroidProductId)
		copy(dAtA[i:], m.AndroidProductId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.AndroidProductId)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.IosManageUrl) > 0 {
		i -= len(m.IosManageUrl)
		copy(dAtA[i:], m.IosManageUrl)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IosManageUrl)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.IosProductId) > 0 {
		i -= len(m.IosProductId)
		copy(dAtA[i:], m.IosProductId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.IosProductId)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.StripeManageUrl) > 0 {
		i -= len(m.StripeManageUrl)
		copy(dAtA[i:], m.StripeManageUrl)
		i = encodeVarintModels(dAtA, i, uint64(len(m.StripeManageUrl)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.StripeProductId) > 0 {
		i -= len(m.StripeProductId)
		copy(dAtA[i:], m.StripeProductId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.StripeProductId)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.ColorStr) > 0 {
		i -= len(m.ColorStr)
		copy(dAtA[i:], m.ColorStr)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ColorStr)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Features) > 0 {
		for iNdEx := len(m.Features) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Features[iNdEx])
			copy(dAtA[i:], m.Features[iNdEx])
			i = encodeVarintModels(dAtA, i, uint64(len(m.Features[iNdEx])))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.AnyNameMinLength != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.AnyNameMinLength))
		i--
		dAtA[i] = 0x48
	}
	if m.AnyNamesCountIncluded != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.AnyNamesCountIncluded))
		i--
		dAtA[i] = 0x40
	}
	if m.PriceStripeUsdCents != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.PriceStripeUsdCents))
		i--
		dAtA[i] = 0x38
	}
	if m.PeriodValue != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.PeriodValue))
		i--
		dAtA[i] = 0x30
	}
	if m.PeriodType != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.PeriodType))
		i--
		dAtA[i] = 0x28
	}
	if m.IsTest {
		i--
		if m.IsTest {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Detail) 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 *Detail) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Detail) 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 = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeviceInfo) 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 *DeviceInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeviceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsConnected {
		i--
		if m.IsConnected {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Archived {
		i--
		if m.Archived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.AddDate != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.AddDate))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintModels(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 = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChatState) 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 *ChatState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Order != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Order))
		i--
		dAtA[i] = 0x20
	}
	if len(m.LastStateId) > 0 {
		i -= len(m.LastStateId)
		copy(dAtA[i:], m.LastStateId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.LastStateId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Mentions != nil {
		{
			size, err := m.Mentions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Messages != nil {
		{
			size, err := m.Messages.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChatStateUnreadState) 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 *ChatStateUnreadState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatStateUnreadState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counter != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Counter))
		i--
		dAtA[i] = 0x10
	}
	if len(m.OldestOrderId) > 0 {
		i -= len(m.OldestOrderId)
		copy(dAtA[i:], m.OldestOrderId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.OldestOrderId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChatMessage) 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 *ChatMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.HasMention {
		i--
		if m.HasMention {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x70
	}
	if m.Synced {
		i--
		if m.Synced {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.MentionRead {
		i--
		if m.MentionRead {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if len(m.StateId) > 0 {
		i -= len(m.StateId)
		copy(dAtA[i:], m.StateId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.StateId)))
		i--
		dAtA[i] = 0x5a
	}
	if m.Read {
		i--
		if m.Read {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.ModifiedAt != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.ModifiedAt))
		i--
		dAtA[i] = 0x48
	}
	if m.Reactions != nil {
		{
			size, err := m.Reactions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.Attachments) > 0 {
		for iNdEx := len(m.Attachments) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attachments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintModels(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.ReplyToMessageId) > 0 {
		i -= len(m.ReplyToMessageId)
		copy(dAtA[i:], m.ReplyToMessageId)
		i = encodeVarintModels(dAtA, i, uint64(len(m.ReplyToMessageId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.CreatedAt != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.OrderId) > 0 {
		i -= len(m.OrderId)
		copy(dAtA[i:], m.OrderId)
		i = encodeVarintModels(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 = encodeVarintModels(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChatMessageMessageContent) 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 *ChatMessageMessageContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatMessageMessageContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Marks) > 0 {
		for iNdEx := len(m.Marks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Marks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintModels(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Style != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Text) > 0 {
		i -= len(m.Text)
		copy(dAtA[i:], m.Text)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Text)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChatMessageAttachment) 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 *ChatMessageAttachment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatMessageAttachment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintModels(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Target) > 0 {
		i -= len(m.Target)
		copy(dAtA[i:], m.Target)
		i = encodeVarintModels(dAtA, i, uint64(len(m.Target)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ChatMessageReactions) 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 *ChatMessageReactions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatMessageReactions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reactions) > 0 {
		for k := range m.Reactions {
			v := m.Reactions[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintModels(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintModels(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintModels(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ChatMessageReactionsIdentityList) 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 *ChatMessageReactionsIdentityList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChatMessageReactionsIdentityList) 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 = encodeVarintModels(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintModels(dAtA []byte, offset int, v uint64) int {
	offset -= sovModels(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *SmartBlockSnapshotBase) 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 + sovModels(uint64(l))
		}
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.FileKeys != nil {
		l = m.FileKeys.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.ExtraRelations) > 0 {
		for _, e := range m.ExtraRelations {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.ObjectTypes) > 0 {
		for _, s := range m.ObjectTypes {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.Collections != nil {
		l = m.Collections.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.RelationLinks) > 0 {
		for _, e := range m.RelationLinks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.RemovedCollectionKeys) > 0 {
		for _, s := range m.RemovedCollectionKeys {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.OriginalCreatedTimestamp != 0 {
		n += 1 + sovModels(uint64(m.OriginalCreatedTimestamp))
	}
	if m.FileInfo != nil {
		l = m.FileInfo.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Search) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *SearchResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Meta) > 0 {
		for _, e := range m.Meta {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *SearchMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Highlight)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.HighlightRanges) > 0 {
		for _, e := range m.HighlightRanges {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.RelationDetails != nil {
		l = m.RelationDetails.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Block) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Restrictions != nil {
		l = m.Restrictions.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.ChildrenIds) > 0 {
		for _, s := range m.ChildrenIds {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.BackgroundColor)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Align != 0 {
		n += 1 + sovModels(uint64(m.Align))
	}
	if m.VerticalAlign != 0 {
		n += 1 + sovModels(uint64(m.VerticalAlign))
	}
	if m.Content != nil {
		n += m.Content.Size()
	}
	return n
}

func (m *BlockContentOfSmartblock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Smartblock != nil {
		l = m.Smartblock.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Text != nil {
		l = m.Text.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfLayout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Layout != nil {
		l = m.Layout.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Div != nil {
		l = m.Div.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Bookmark != nil {
		l = m.Bookmark.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfIcon) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Icon != nil {
		l = m.Icon.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Link != nil {
		l = m.Link.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfDataview) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Dataview != nil {
		l = m.Dataview.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfFeaturedRelations) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FeaturedRelations != nil {
		l = m.FeaturedRelations.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfLatex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Latex != nil {
		l = m.Latex.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfTableOfContents) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableOfContents != nil {
		l = m.TableOfContents.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfTable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Table != nil {
		l = m.Table.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfTableColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableColumn != nil {
		l = m.TableColumn.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfTableRow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TableRow != nil {
		l = m.TableRow.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfWidget) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Widget != nil {
		l = m.Widget.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentOfChat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Chat != nil {
		l = m.Chat.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Read {
		n += 2
	}
	if m.Edit {
		n += 2
	}
	if m.Remove {
		n += 2
	}
	if m.Drag {
		n += 2
	}
	if m.DropOn {
		n += 2
	}
	return n
}

func (m *BlockContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentLayout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Style != 0 {
		n += 1 + sovModels(uint64(m.Style))
	}
	return n
}

func (m *BlockContentLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TargetBlockId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Style != 0 {
		n += 1 + sovModels(uint64(m.Style))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.IconSize != 0 {
		n += 1 + sovModels(uint64(m.IconSize))
	}
	if m.CardStyle != 0 {
		n += 1 + sovModels(uint64(m.CardStyle))
	}
	if m.Description != 0 {
		n += 1 + sovModels(uint64(m.Description))
	}
	if len(m.Relations) > 0 {
		for _, s := range m.Relations {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *BlockContentDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Style != 0 {
		n += 1 + sovModels(uint64(m.Style))
	}
	return n
}

func (m *BlockContentBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.ImageHash)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.FaviconHash)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	l = len(m.TargetObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovModels(uint64(m.State))
	}
	return n
}

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

func (m *BlockContentFeaturedRelations) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Style != 0 {
		n += 1 + sovModels(uint64(m.Style))
	}
	if m.Marks != nil {
		l = m.Marks.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Checked {
		n += 2
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IconEmoji)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IconImage)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentTextMarks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Marks) > 0 {
		for _, e := range m.Marks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *BlockContentTextMark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	l = len(m.Param)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	l = len(m.Mime)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovModels(uint64(m.Size_))
	}
	if m.AddedAt != 0 {
		n += 1 + sovModels(uint64(m.AddedAt))
	}
	if m.State != 0 {
		n += 1 + sovModels(uint64(m.State))
	}
	if m.Style != 0 {
		n += 1 + sovModels(uint64(m.Style))
	}
	l = len(m.TargetObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentSmartblock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentDataview) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.Views) > 0 {
		for _, e := range m.Views {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.ActiveView)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.RelationLinks) > 0 {
		for _, e := range m.RelationLinks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.TargetObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.GroupOrders) > 0 {
		for _, e := range m.GroupOrders {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.ObjectOrders) > 0 {
		for _, e := range m.ObjectOrders {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.IsCollection {
		n += 2
	}
	return n
}

func (m *BlockContentDataviewView) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Sorts) > 0 {
		for _, e := range m.Sorts {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.Filters) > 0 {
		for _, e := range m.Filters {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.CoverRelationKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.HideIcon {
		n += 2
	}
	if m.CardSize != 0 {
		n += 1 + sovModels(uint64(m.CardSize))
	}
	if m.CoverFit {
		n += 2
	}
	l = len(m.GroupRelationKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.GroupBackgroundColors {
		n += 2
	}
	if m.PageLimit != 0 {
		n += 1 + sovModels(uint64(m.PageLimit))
	}
	l = len(m.DefaultTemplateId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.DefaultObjectTypeId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.EndRelationKey)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentDataviewRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.IsVisible {
		n += 2
	}
	if m.Width != 0 {
		n += 1 + sovModels(uint64(m.Width))
	}
	if m.DateIncludeTime {
		n += 2
	}
	if m.TimeFormat != 0 {
		n += 1 + sovModels(uint64(m.TimeFormat))
	}
	if m.DateFormat != 0 {
		n += 1 + sovModels(uint64(m.DateFormat))
	}
	if m.Formula != 0 {
		n += 1 + sovModels(uint64(m.Formula))
	}
	if m.Align != 0 {
		n += 1 + sovModels(uint64(m.Align))
	}
	return n
}

func (m *BlockContentDataviewSort) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	if len(m.CustomOrder) > 0 {
		for _, e := range m.CustomOrder {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.Format != 0 {
		n += 1 + sovModels(uint64(m.Format))
	}
	if m.IncludeTime {
		n += 2
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.EmptyPlacement != 0 {
		n += 1 + sovModels(uint64(m.EmptyPlacement))
	}
	if m.NoCollate {
		n += 2
	}
	return n
}

func (m *BlockContentDataviewFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operator != 0 {
		n += 1 + sovModels(uint64(m.Operator))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Condition != 0 {
		n += 1 + sovModels(uint64(m.Condition))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.RelationProperty)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.QuickOption != 0 {
		n += 1 + sovModels(uint64(m.QuickOption))
	}
	if m.Format != 0 {
		n += 1 + sovModels(uint64(m.Format))
	}
	if m.IncludeTime {
		n += 2
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.NestedFilters) > 0 {
		for _, e := range m.NestedFilters {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *BlockContentDataviewGroupOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.ViewGroups) > 0 {
		for _, e := range m.ViewGroups {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *BlockContentDataviewViewGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GroupId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovModels(uint64(m.Index))
	}
	if m.Hidden {
		n += 2
	}
	l = len(m.BackgroundColor)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentDataviewObjectOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.GroupId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.ObjectIds) > 0 {
		for _, s := range m.ObjectIds {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *BlockContentDataviewGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *BlockContentDataviewGroupValueOfStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentDataviewGroupValueOfTag) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tag != nil {
		l = m.Tag.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentDataviewGroupValueOfCheckbox) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Checkbox != nil {
		l = m.Checkbox.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentDataviewGroupValueOfDate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Date != nil {
		l = m.Date.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *BlockContentDataviewStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentDataviewTag) 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 + sovModels(uint64(l))
		}
	}
	return n
}

func (m *BlockContentDataviewCheckbox) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Checked {
		n += 2
	}
	return n
}

func (m *BlockContentDataviewDate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *BlockContentLatex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Processor != 0 {
		n += 1 + sovModels(uint64(m.Processor))
	}
	return n
}

func (m *BlockContentTableOfContents) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentTable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentTableColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockContentTableRow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsHeader {
		n += 2
	}
	return n
}

func (m *BlockContentWidget) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Layout != 0 {
		n += 1 + sovModels(uint64(m.Layout))
	}
	if m.Limit != 0 {
		n += 1 + sovModels(uint64(m.Limit))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.AutoAdded {
		n += 2
	}
	return n
}

func (m *BlockContentChat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *BlockMetaOnly) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Range) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.From != 0 {
		n += 1 + sovModels(uint64(m.From))
	}
	if m.To != 0 {
		n += 1 + sovModels(uint64(m.To))
	}
	return n
}

func (m *Account) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *AccountConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EnableDataview {
		n += 2
	}
	if m.EnableDebug {
		n += 2
	}
	if m.EnablePrereleaseChannel {
		n += 2
	}
	if m.EnableSpaces {
		n += 2
	}
	if m.Extra != nil {
		l = m.Extra.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}

func (m *AccountStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StatusType != 0 {
		n += 1 + sovModels(uint64(m.StatusType))
	}
	if m.DeletionDate != 0 {
		n += 1 + sovModels(uint64(m.DeletionDate))
	}
	return n
}

func (m *AccountInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.HomeObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.ArchiveObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.ProfileObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.DeviceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.AccountSpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.WidgetsId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.MarketplaceWorkspaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceViewId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.TechSpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.WorkspaceObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceChatId)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.GatewayUrl)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.LocalStoragePath)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.TimeZone)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.AnalyticsId)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.NetworkId)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.EthereumAddress)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}

func (m *AccountAuth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AccountAuthAppInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppHash)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.AppName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.AppKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovModels(uint64(m.CreatedAt))
	}
	if m.ExpireAt != 0 {
		n += 1 + sovModels(uint64(m.ExpireAt))
	}
	if m.Scope != 0 {
		n += 1 + sovModels(uint64(m.Scope))
	}
	if m.IsActive {
		n += 2
	}
	return n
}

func (m *LinkPreview) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.ImageUrl)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.FaviconUrl)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	return n
}

func (m *Restrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Object) > 0 {
		l = 0
		for _, e := range m.Object {
			l += sovModels(uint64(e))
		}
		n += 1 + sovModels(uint64(l)) + l
	}
	if len(m.Dataview) > 0 {
		for _, e := range m.Dataview {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *RestrictionsDataviewRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Restrictions) > 0 {
		l = 0
		for _, e := range m.Restrictions {
			l += sovModels(uint64(e))
		}
		n += 1 + sovModels(uint64(l)) + l
	}
	return n
}

func (m *Object) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ObjectChangePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SmartBlockType != 0 {
		n += 1 + sovModels(uint64(m.SmartBlockType))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *SpaceObjectHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceID)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *ObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.RelationLinks) > 0 {
		for _, e := range m.RelationLinks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.Layout != 0 {
		n += 1 + sovModels(uint64(m.Layout))
	}
	l = len(m.IconEmoji)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Hidden {
		n += 2
	}
	if len(m.Types) > 0 {
		l = 0
		for _, e := range m.Types {
			l += sovModels(uint64(e))
		}
		n += 1 + sovModels(uint64(l)) + l
	}
	if m.IsArchived {
		n += 2
	}
	if m.Readonly {
		n += 2
	}
	if m.InstalledByDefault {
		n += 2
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Revision != 0 {
		n += 1 + sovModels(uint64(m.Revision))
	}
	if m.RestrictObjectCreation {
		n += 2
	}
	if m.IconColor != 0 {
		n += 1 + sovModels(uint64(m.IconColor))
	}
	l = len(m.IconName)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.PluralName)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Layout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovModels(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.RequiredRelations) > 0 {
		for _, e := range m.RequiredRelations {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *RelationWithValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Relation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Format != 0 {
		n += 1 + sovModels(uint64(m.Format))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.DefaultValue != nil {
		l = m.DefaultValue.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.DataSource != 0 {
		n += 1 + sovModels(uint64(m.DataSource))
	}
	if m.Hidden {
		n += 2
	}
	if m.ReadOnly {
		n += 2
	}
	if m.Multi {
		n += 2
	}
	if len(m.ObjectTypes) > 0 {
		for _, s := range m.ObjectTypes {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.SelectDict) > 0 {
		for _, e := range m.SelectDict {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.MaxCount != 0 {
		n += 1 + sovModels(uint64(m.MaxCount))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.ReadOnlyRelation {
		n += 2
	}
	if m.Scope != 0 {
		n += 2 + sovModels(uint64(m.Scope))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	if m.Revision != 0 {
		n += 2 + sovModels(uint64(m.Revision))
	}
	if m.IncludeTime {
		n += 3
	}
	l = len(m.Id)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}

func (m *RelationOption) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *RelationLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Format != 0 {
		n += 1 + sovModels(uint64(m.Format))
	}
	return n
}

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

func (m *RelationOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Options) > 0 {
		for _, e := range m.Options {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *InternalFlag) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovModels(uint64(m.Value))
	}
	return n
}

func (m *ObjectView) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RootId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.Details) > 0 {
		for _, e := range m.Details {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.Restrictions != nil {
		l = m.Restrictions.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.History != nil {
		l = m.History.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.RelationLinks) > 0 {
		for _, e := range m.RelationLinks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if len(m.BlockParticipants) > 0 {
		for _, e := range m.BlockParticipants {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *ObjectViewDetailsSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *ObjectViewRelationWithValuePerObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *ObjectViewHistorySize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Undo != 0 {
		n += 1 + sovModels(uint64(m.Undo))
	}
	if m.Redo != 0 {
		n += 1 + sovModels(uint64(m.Redo))
	}
	return n
}

func (m *ObjectViewBlockParticipant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.ParticipantId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *ParticipantPermissionChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Perms != 0 {
		n += 1 + sovModels(uint64(m.Perms))
	}
	return n
}

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

func (m *MetadataPayloadOfIdentity) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Identity != nil {
		l = m.Identity.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *MetadataPayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MetadataPayloadIdentityPayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProfileSymKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Notification) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.CreateTime != 0 {
		n += 1 + sovModels(uint64(m.CreateTime))
	}
	if m.Status != 0 {
		n += 1 + sovModels(uint64(m.Status))
	}
	if m.IsLocal {
		n += 2
	}
	if m.Payload != nil {
		n += m.Payload.Size()
	}
	l = len(m.Space)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.AclHeadId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationPayloadOfImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Import != nil {
		l = m.Import.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Export != nil {
		l = m.Export.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfGalleryImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GalleryImport != nil {
		l = m.GalleryImport.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfRequestToJoin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestToJoin != nil {
		l = m.RequestToJoin.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfTest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Test != nil {
		l = m.Test.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfParticipantRequestApproved) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParticipantRequestApproved != nil {
		l = m.ParticipantRequestApproved.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfRequestToLeave) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestToLeave != nil {
		l = m.RequestToLeave.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfParticipantRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParticipantRemove != nil {
		l = m.ParticipantRemove.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfParticipantRequestDecline) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParticipantRequestDecline != nil {
		l = m.ParticipantRequestDecline.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationPayloadOfParticipantPermissionsChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParticipantPermissionsChange != nil {
		l = m.ParticipantPermissionsChange.Size()
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}
func (m *NotificationImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcessId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.ErrorCode != 0 {
		n += 1 + sovModels(uint64(m.ErrorCode))
	}
	if m.ImportType != 0 {
		n += 1 + sovModels(uint64(m.ImportType))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ErrorCode != 0 {
		n += 1 + sovModels(uint64(m.ErrorCode))
	}
	if m.ExportType != 0 {
		n += 1 + sovModels(uint64(m.ExportType))
	}
	return n
}

func (m *NotificationGalleryImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcessId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.ErrorCode != 0 {
		n += 1 + sovModels(uint64(m.ErrorCode))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationRequestToJoin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IdentityName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IdentityIcon)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationTest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *NotificationParticipantRequestApproved) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Permissions != 0 {
		n += 1 + sovModels(uint64(m.Permissions))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationRequestToLeave) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IdentityName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IdentityIcon)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationParticipantRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IdentityName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IdentityIcon)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationParticipantRequestDecline) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *NotificationParticipantPermissionsChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Permissions != 0 {
		n += 1 + sovModels(uint64(m.Permissions))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Export) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *Import) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *Invite) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *InvitePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CreatorIdentity)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.CreatorName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.AclKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.SpaceIconCid)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.SpaceIconEncryptionKeys) > 0 {
		for _, e := range m.SpaceIconEncryptionKeys {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.InviteType != 0 {
		n += 1 + sovModels(uint64(m.InviteType))
	}
	l = len(m.GuestKey)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *IdentityProfile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IconCid)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.IconEncryptionKeys) > 0 {
		for _, e := range m.IconEncryptionKeys {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.GlobalName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *FileInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FileId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.EncryptionKeys) > 0 {
		for _, e := range m.EncryptionKeys {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *FileEncryptionKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *ManifestInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Schema)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Author)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.License)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Screenshots) > 0 {
		for _, s := range m.Screenshots {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.DownloadLink)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.FileSize != 0 {
		n += 1 + sovModels(uint64(m.FileSize))
	}
	if len(m.Categories) > 0 {
		for _, s := range m.Categories {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.Language)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Membership) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tier != 0 {
		n += 1 + sovModels(uint64(m.Tier))
	}
	if m.Status != 0 {
		n += 1 + sovModels(uint64(m.Status))
	}
	if m.DateStarted != 0 {
		n += 1 + sovModels(uint64(m.DateStarted))
	}
	if m.DateEnds != 0 {
		n += 1 + sovModels(uint64(m.DateEnds))
	}
	if m.IsAutoRenew {
		n += 2
	}
	if m.PaymentMethod != 0 {
		n += 1 + sovModels(uint64(m.PaymentMethod))
	}
	l = len(m.NsName)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.NsNameType != 0 {
		n += 1 + sovModels(uint64(m.NsNameType))
	}
	l = len(m.UserEmail)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.SubscribeToNewsletter {
		n += 2
	}
	return n
}

func (m *MembershipTierData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovModels(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.IsTest {
		n += 2
	}
	if m.PeriodType != 0 {
		n += 1 + sovModels(uint64(m.PeriodType))
	}
	if m.PeriodValue != 0 {
		n += 1 + sovModels(uint64(m.PeriodValue))
	}
	if m.PriceStripeUsdCents != 0 {
		n += 1 + sovModels(uint64(m.PriceStripeUsdCents))
	}
	if m.AnyNamesCountIncluded != 0 {
		n += 1 + sovModels(uint64(m.AnyNamesCountIncluded))
	}
	if m.AnyNameMinLength != 0 {
		n += 1 + sovModels(uint64(m.AnyNameMinLength))
	}
	if len(m.Features) > 0 {
		for _, s := range m.Features {
			l = len(s)
			n += 1 + l + sovModels(uint64(l))
		}
	}
	l = len(m.ColorStr)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.StripeProductId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.StripeManageUrl)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IosProductId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.IosManageUrl)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.AndroidProductId)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.AndroidManageUrl)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	l = len(m.Offer)
	if l > 0 {
		n += 2 + l + sovModels(uint64(l))
	}
	return n
}

func (m *Detail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	return n
}

func (m *DeviceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.AddDate != 0 {
		n += 1 + sovModels(uint64(m.AddDate))
	}
	if m.Archived {
		n += 2
	}
	if m.IsConnected {
		n += 2
	}
	return n
}

func (m *ChatState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Messages != nil {
		l = m.Messages.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Mentions != nil {
		l = m.Mentions.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.LastStateId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Order != 0 {
		n += 1 + sovModels(uint64(m.Order))
	}
	return n
}

func (m *ChatStateUnreadState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OldestOrderId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Counter != 0 {
		n += 1 + sovModels(uint64(m.Counter))
	}
	return n
}

func (m *ChatMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.OrderId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovModels(uint64(m.CreatedAt))
	}
	l = len(m.ReplyToMessageId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if len(m.Attachments) > 0 {
		for _, e := range m.Attachments {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	if m.Reactions != nil {
		l = m.Reactions.Size()
		n += 1 + l + sovModels(uint64(l))
	}
	if m.ModifiedAt != 0 {
		n += 1 + sovModels(uint64(m.ModifiedAt))
	}
	if m.Read {
		n += 2
	}
	l = len(m.StateId)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.MentionRead {
		n += 2
	}
	if m.Synced {
		n += 2
	}
	if m.HasMention {
		n += 2
	}
	return n
}

func (m *ChatMessageMessageContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Style != 0 {
		n += 1 + sovModels(uint64(m.Style))
	}
	if len(m.Marks) > 0 {
		for _, e := range m.Marks {
			l = e.Size()
			n += 1 + l + sovModels(uint64(l))
		}
	}
	return n
}

func (m *ChatMessageAttachment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Target)
	if l > 0 {
		n += 1 + l + sovModels(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovModels(uint64(m.Type))
	}
	return n
}

func (m *ChatMessageReactions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Reactions) > 0 {
		for k, v := range m.Reactions {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovModels(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovModels(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovModels(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ChatMessageReactionsIdentityList) 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 + sovModels(uint64(l))
		}
	}
	return n
}

func sovModels(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozModels(x uint64) (n int) {
	return sovModels(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SmartBlockSnapshotBase) 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 ErrIntOverflowModels
			}
			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: SmartBlockSnapshotBase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SmartBlockSnapshotBase: 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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Blocks = append(m.Blocks, &Block{})
			if err := m.Blocks[len(m.Blocks)-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 Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 FileKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileKeys == nil {
				m.FileKeys = &types.Struct{}
			}
			if err := m.FileKeys.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraRelations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExtraRelations = append(m.ExtraRelations, &Relation{})
			if err := m.ExtraRelations[len(m.ExtraRelations)-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 ObjectTypes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypes = append(m.ObjectTypes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collections", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Collections == nil {
				m.Collections = &types.Struct{}
			}
			if err := m.Collections.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationLinks = append(m.RelationLinks, &RelationLink{})
			if err := m.RelationLinks[len(m.RelationLinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemovedCollectionKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RemovedCollectionKeys = append(m.RemovedCollectionKeys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginalCreatedTimestamp", wireType)
			}
			m.OriginalCreatedTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OriginalCreatedTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileInfo == nil {
				m.FileInfo = &FileInfo{}
			}
			if err := m.FileInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Search) 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 ErrIntOverflowModels
			}
			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: Search: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Search: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SearchResult) 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 ErrIntOverflowModels
			}
			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: Result: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectId = 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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Meta = append(m.Meta, &SearchMeta{})
			if err := m.Meta[len(m.Meta)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SearchMeta) 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 ErrIntOverflowModels
			}
			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: Meta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Meta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Highlight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Highlight = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HighlightRanges", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HighlightRanges = append(m.HighlightRanges, &Range{})
			if err := m.HighlightRanges[len(m.HighlightRanges)-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 BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RelationDetails == nil {
				m.RelationDetails = &types.Struct{}
			}
			if err := m.RelationDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Block) 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 ErrIntOverflowModels
			}
			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 {
		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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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
		case 3:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restrictions == nil {
				m.Restrictions = &BlockRestrictions{}
			}
			if err := m.Restrictions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildrenIds = append(m.ChildrenIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BackgroundColor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Align |= BlockAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VerticalAlign |= BlockVerticalAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Smartblock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentSmartblock{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfSmartblock{v}
			iNdEx = postIndex
		case 14:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentText{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfText{v}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentFile{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfFile{v}
			iNdEx = postIndex
		case 16:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentLayout{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfLayout{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Div", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentDiv{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfDiv{v}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bookmark", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentBookmark{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfBookmark{v}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentIcon{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfIcon{v}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Link", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentLink{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfLink{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dataview", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentDataview{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfDataview{v}
			iNdEx = postIndex
		case 22:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentRelation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfRelation{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeaturedRelations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentFeaturedRelations{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfFeaturedRelations{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Latex", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentLatex{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfLatex{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableOfContents", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentTableOfContents{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfTableOfContents{v}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentTable{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfTable{v}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableColumn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentTableColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfTableColumn{v}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableRow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentTableRow{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfTableRow{v}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Widget", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentWidget{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfWidget{v}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentChat{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Content = &BlockContentOfChat{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockRestrictions) 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 ErrIntOverflowModels
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Read = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Edit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Edit = bool(v != 0)
		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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Remove = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Drag", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Drag = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropOn", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DropOn = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContent) 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 ErrIntOverflowModels
			}
			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: Content: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Content: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentLayout) 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 ErrIntOverflowModels
			}
			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 Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= BlockContentLayoutStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentLink) 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 ErrIntOverflowModels
			}
			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 TargetBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= BlockContentLinkStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconSize", wireType)
			}
			m.IconSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IconSize |= BlockContentLinkIconSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CardStyle", wireType)
			}
			m.CardStyle = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CardStyle |= BlockContentLinkCardStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			m.Description = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Description |= BlockContentLinkDescription(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDiv) 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 ErrIntOverflowModels
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= BlockContentDivStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentBookmark) 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 ErrIntOverflowModels
			}
			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 Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FaviconHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FaviconHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= LinkPreviewType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= BlockContentBookmarkState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentIcon) 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 ErrIntOverflowModels
			}
			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: Icon: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Icon: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentFeaturedRelations) 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 ErrIntOverflowModels
			}
			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: FeaturedRelations: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FeaturedRelations: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentText) 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 ErrIntOverflowModels
			}
			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 Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Marks == nil {
				m.Marks = &BlockContentTextMarks{}
			}
			if err := m.Marks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Checked = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEmoji", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconEmoji = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconImage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconImage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentTextMarks) 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 ErrIntOverflowModels
			}
			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 Marks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Marks = append(m.Marks, &BlockContentTextMark{})
			if err := m.Marks[len(m.Marks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentTextMark) 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 ErrIntOverflowModels
			}
			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: Mark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Mark: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Range == nil {
				m.Range = &Range{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= BlockContentTextMarkType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Param", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Param = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentFile) 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 ErrIntOverflowModels
			}
			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 Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= BlockContentFileType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddedAt", wireType)
			}
			m.AddedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= BlockContentFileState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= BlockContentFileStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentSmartblock) 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 ErrIntOverflowModels
			}
			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: Smartblock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Smartblock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataview) 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 ErrIntOverflowModels
			}
			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 {
		case 1:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Views", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Views = append(m.Views, &BlockContentDataviewView{})
			if err := m.Views[len(m.Views)-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 ActiveView", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActiveView = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, &Relation{})
			if err := m.Relations[len(m.Relations)-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 RelationLinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationLinks = append(m.RelationLinks, &RelationLink{})
			if err := m.RelationLinks[len(m.RelationLinks)-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 TargetObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupOrders = append(m.GroupOrders, &BlockContentDataviewGroupOrder{})
			if err := m.GroupOrders[len(m.GroupOrders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectOrders = append(m.ObjectOrders, &BlockContentDataviewObjectOrder{})
			if err := m.ObjectOrders[len(m.ObjectOrders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsCollection", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsCollection = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewView) 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 ErrIntOverflowModels
			}
			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: View: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: View: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= BlockContentDataviewViewType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sorts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sorts = append(m.Sorts, &BlockContentDataviewSort{})
			if err := m.Sorts[len(m.Sorts)-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 Filters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filters = append(m.Filters, &BlockContentDataviewFilter{})
			if err := m.Filters[len(m.Filters)-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 Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, &BlockContentDataviewRelation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CoverRelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowModels
				}
				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 9:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CardSize |= BlockContentDataviewViewSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			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 ErrIntOverflowModels
				}
				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 11:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupRelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			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 ErrIntOverflowModels
				}
				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 13:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PageLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndRelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewRelation) 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 ErrIntOverflowModels
			}
			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 Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsVisible", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsVisible = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateIncludeTime", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DateIncludeTime = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeFormat", wireType)
			}
			m.TimeFormat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeFormat |= BlockContentDataviewRelationTimeFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateFormat", wireType)
			}
			m.DateFormat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DateFormat |= BlockContentDataviewRelationDateFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Formula", wireType)
			}
			m.Formula = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Formula |= BlockContentDataviewRelationFormulaType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Align |= BlockAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewSort) 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 ErrIntOverflowModels
			}
			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 RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= BlockContentDataviewSortType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomOrder", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CustomOrder = append(m.CustomOrder, &types.Value{})
			if err := m.CustomOrder[len(m.CustomOrder)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= RelationFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeTime", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeTime = bool(v != 0)
		case 6:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EmptyPlacement", wireType)
			}
			m.EmptyPlacement = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EmptyPlacement |= BlockContentDataviewSortEmptyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoCollate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoCollate = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewFilter) 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 ErrIntOverflowModels
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
			}
			m.Operator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Operator |= BlockContentDataviewFilterOperator(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Condition", wireType)
			}
			m.Condition = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Condition |= BlockContentDataviewFilterCondition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationProperty", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationProperty = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QuickOption", wireType)
			}
			m.QuickOption = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QuickOption |= BlockContentDataviewFilterQuickOption(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= RelationFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeTime", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeTime = bool(v != 0)
		case 9:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedFilters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NestedFilters = append(m.NestedFilters, &BlockContentDataviewFilter{})
			if err := m.NestedFilters[len(m.NestedFilters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewGroupOrder) 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 ErrIntOverflowModels
			}
			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: GroupOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewGroups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewGroups = append(m.ViewGroups, &BlockContentDataviewViewGroup{})
			if err := m.ViewGroups[len(m.ViewGroups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewViewGroup) 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 ErrIntOverflowModels
			}
			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: ViewGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hidden = bool(v != 0)
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BackgroundColor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewGroup) 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 ErrIntOverflowModels
			}
			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: Group: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Group: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentDataviewStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &BlockContentDataviewGroupValueOfStatus{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentDataviewTag{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &BlockContentDataviewGroupValueOfTag{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checkbox", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentDataviewCheckbox{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &BlockContentDataviewGroupValueOfCheckbox{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Date", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BlockContentDataviewDate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &BlockContentDataviewGroupValueOfDate{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewStatus) 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 ErrIntOverflowModels
			}
			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 {
		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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewTag) 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 ErrIntOverflowModels
			}
			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: Tag: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tag: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewCheckbox) 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 ErrIntOverflowModels
			}
			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: Checkbox: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Checkbox: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Checked = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentDataviewDate) 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 ErrIntOverflowModels
			}
			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: Date: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Date: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentRelation) 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 ErrIntOverflowModels
			}
			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 Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentLatex) 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 ErrIntOverflowModels
			}
			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 Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Processor", wireType)
			}
			m.Processor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Processor |= BlockContentLatexProcessor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentTableOfContents) 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 ErrIntOverflowModels
			}
			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: TableOfContents: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableOfContents: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentTable) 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 ErrIntOverflowModels
			}
			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: Table: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Table: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentTableColumn) 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 ErrIntOverflowModels
			}
			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: TableColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentTableRow) 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 ErrIntOverflowModels
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsHeader", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsHeader = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentWidget) 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 ErrIntOverflowModels
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Layout", wireType)
			}
			m.Layout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Layout |= BlockContentWidgetLayout(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoAdded", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AutoAdded = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockContentChat) 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 ErrIntOverflowModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockMetaOnly) 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 ErrIntOverflowModels
			}
			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: BlockMetaOnly: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockMetaOnly: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Range) 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 ErrIntOverflowModels
			}
			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: Range: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			m.From = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.From |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			m.To = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.To |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Account) 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 ErrIntOverflowModels
			}
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &AccountConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &AccountStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &AccountInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountConfig) 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 ErrIntOverflowModels
			}
			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 {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableDataview", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableDataview = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableDebug", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableDebug = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnablePrereleaseChannel", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnablePrereleaseChannel = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableSpaces", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableSpaces = bool(v != 0)
		case 100:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Extra == nil {
				m.Extra = &types.Struct{}
			}
			if err := m.Extra.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountStatus) 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 ErrIntOverflowModels
			}
			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 {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusType", wireType)
			}
			m.StatusType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StatusType |= AccountStatusType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeletionDate", wireType)
			}
			m.DeletionDate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeletionDate |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountInfo) 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 ErrIntOverflowModels
			}
			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: Info: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Info: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HomeObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HomeObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArchiveObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ArchiveObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountSpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountSpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WidgetsId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WidgetsId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketplaceWorkspaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketplaceWorkspaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TechSpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TechSpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkspaceObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkspaceObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceChatId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceChatId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 101:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GatewayUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 103:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalStoragePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalStoragePath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 104:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeZone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TimeZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 105:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnalyticsId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AnalyticsId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 106:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 107:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EthereumAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EthereumAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountAuth) 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 ErrIntOverflowModels
			}
			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: Auth: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Auth: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountAuthAppInfo) 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 ErrIntOverflowModels
			}
			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: AppInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppHash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpireAt", wireType)
			}
			m.ExpireAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpireAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Scope |= AccountAuthLocalApiScope(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsActive = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LinkPreview) 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 ErrIntOverflowModels
			}
			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: LinkPreview: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LinkPreview: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FaviconUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FaviconUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= LinkPreviewType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Restrictions) 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 ErrIntOverflowModels
			}
			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 == 0 {
				var v RestrictionsObjectRestriction
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= RestrictionsObjectRestriction(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Object = append(m.Object, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthModels
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthModels
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Object) == 0 {
					m.Object = make([]RestrictionsObjectRestriction, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v RestrictionsObjectRestriction
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowModels
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= RestrictionsObjectRestriction(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Object = append(m.Object, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dataview", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dataview = append(m.Dataview, &RestrictionsDataviewRestrictions{})
			if err := m.Dataview[len(m.Dataview)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RestrictionsDataviewRestrictions) 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 ErrIntOverflowModels
			}
			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: DataviewRestrictions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataviewRestrictions: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v RestrictionsDataviewRestriction
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= RestrictionsDataviewRestriction(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Restrictions = append(m.Restrictions, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthModels
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthModels
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Restrictions) == 0 {
					m.Restrictions = make([]RestrictionsDataviewRestriction, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v RestrictionsDataviewRestriction
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowModels
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= RestrictionsDataviewRestriction(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Restrictions = append(m.Restrictions, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Restrictions", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Object) 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 ErrIntOverflowModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SpaceObjectHeader) 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 ErrIntOverflowModels
			}
			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: SpaceObjectHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpaceObjectHeader: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ObjectType) 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 ErrIntOverflowModels
			}
			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: ObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 RelationLinks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationLinks = append(m.RelationLinks, &RelationLink{})
			if err := m.RelationLinks[len(m.RelationLinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Layout", wireType)
			}
			m.Layout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Layout |= ObjectTypeLayout(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEmoji", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconEmoji = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hidden = bool(v != 0)
		case 8:
			if wireType == 0 {
				var v SmartBlockType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= SmartBlockType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Types = append(m.Types, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthModels
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthModels
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Types) == 0 {
					m.Types = make([]SmartBlockType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v SmartBlockType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowModels
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= SmartBlockType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Types = append(m.Types, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Types", wireType)
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsArchived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsArchived = bool(v != 0)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Readonly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Readonly = bool(v != 0)
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstalledByDefault", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.InstalledByDefault = bool(v != 0)
		case 12:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestrictObjectCreation", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RestrictObjectCreation = bool(v != 0)
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconColor", wireType)
			}
			m.IconColor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IconColor |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PluralName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PluralName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Layout) 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 ErrIntOverflowModels
			}
			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 Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= ObjectTypeLayout(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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 RequiredRelations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequiredRelations = append(m.RequiredRelations, &Relation{})
			if err := m.RequiredRelations[len(m.RequiredRelations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RelationWithValue) 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 ErrIntOverflowModels
			}
			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: RelationWithValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationWithValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relation == nil {
				m.Relation = &Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relation) 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 ErrIntOverflowModels
			}
			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 Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= RelationFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DefaultValue == nil {
				m.DefaultValue = &types.Value{}
			}
			if err := m.DefaultValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataSource", wireType)
			}
			m.DataSource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataSource |= RelationDataSource(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hidden = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReadOnly = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Multi", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Multi = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypes = append(m.ObjectTypes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SelectDict", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SelectDict = append(m.SelectDict, &RelationOption{})
			if err := m.SelectDict[len(m.SelectDict)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxCount", wireType)
			}
			m.MaxCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRelation", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReadOnlyRelation = bool(v != 0)
		case 20:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Scope |= RelationScope(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeTime", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeTime = bool(v != 0)
		case 100:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RelationOption) 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 ErrIntOverflowModels
			}
			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: Option: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Option: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RelationLink) 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 ErrIntOverflowModels
			}
			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: RelationLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationLink: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= RelationFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relations) 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 ErrIntOverflowModels
			}
			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 Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, &Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RelationOptions) 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 ErrIntOverflowModels
			}
			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: RelationOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Options = append(m.Options, &RelationOption{})
			if err := m.Options[len(m.Options)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InternalFlag) 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 ErrIntOverflowModels
			}
			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: InternalFlag: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InternalFlag: 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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= InternalFlagValue(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ObjectView) 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 ErrIntOverflowModels
			}
			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: ObjectView: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectView: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Blocks = append(m.Blocks, &Block{})
			if err := m.Blocks[len(m.Blocks)-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 Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Details = append(m.Details, &ObjectViewDetailsSet{})
			if err := m.Details[len(m.Details)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= SmartBlockType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, &Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restrictions == nil {
				m.Restrictions = &Restrictions{}
			}
			if err := m.Restrictions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field History", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.History == nil {
				m.History = &ObjectViewHistorySize{}
			}
			if err := m.History.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationLinks = append(m.RelationLinks, &RelationLink{})
			if err := m.RelationLinks[len(m.RelationLinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockParticipants", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockParticipants = append(m.BlockParticipants, &ObjectViewBlockParticipant{})
			if err := m.BlockParticipants[len(m.BlockParticipants)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ObjectViewDetailsSet) 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 ErrIntOverflowModels
			}
			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: DetailsSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DetailsSet: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ObjectViewHistorySize) 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 ErrIntOverflowModels
			}
			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: HistorySize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistorySize: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Undo", wireType)
			}
			m.Undo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Undo |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Redo", wireType)
			}
			m.Redo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Redo |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Metadata) 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 ErrIntOverflowModels
			}
			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: Metadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MetadataPayloadIdentityPayload{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &MetadataPayloadOfIdentity{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetadataPayload) 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 ErrIntOverflowModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Notification) 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 ErrIntOverflowModels
			}
			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 {
		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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 CreateTime", wireType)
			}
			m.CreateTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= NotificationStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLocal", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsLocal = bool(v != 0)
		case 6:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationImport{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfImport{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Space", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Space = string(dAtA[iNdEx:postIndex])
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationExport{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfExport{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GalleryImport", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationGalleryImport{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfGalleryImport{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestToJoin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationRequestToJoin{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfRequestToJoin{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Test", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationTest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfTest{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantRequestApproved", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationParticipantRequestApproved{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfParticipantRequestApproved{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclHeadId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AclHeadId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestToLeave", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationRequestToLeave{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfRequestToLeave{v}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationParticipantRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfParticipantRemove{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantRequestDecline", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationParticipantRequestDecline{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfParticipantRequestDecline{v}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipantPermissionsChange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NotificationParticipantPermissionsChange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Payload = &NotificationPayloadOfParticipantPermissionsChange{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationImport) 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 ErrIntOverflowModels
			}
			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 {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType)
			}
			m.ErrorCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrorCode |= ImportErrorCode(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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ImportType |= ImportType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationExport) 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 ErrIntOverflowModels
			}
			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 {
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType)
			}
			m.ErrorCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrorCode |= NotificationExportCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExportType", wireType)
			}
			m.ExportType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExportType |= ExportFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationGalleryImport) 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 ErrIntOverflowModels
			}
			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: GalleryImport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GalleryImport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType)
			}
			m.ErrorCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrorCode |= ImportErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationRequestToJoin) 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 ErrIntOverflowModels
			}
			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: RequestToJoin: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestToJoin: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Identity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationTest) 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 ErrIntOverflowModels
			}
			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: Test: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Test: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationParticipantRequestApproved) 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 ErrIntOverflowModels
			}
			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: ParticipantRequestApproved: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParticipantRequestApproved: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= ParticipantPermissions(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationRequestToLeave) 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 ErrIntOverflowModels
			}
			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: RequestToLeave: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestToLeave: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Identity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationParticipantRemove) 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 ErrIntOverflowModels
			}
			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: ParticipantRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParticipantRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentityIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationParticipantRequestDecline) 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 ErrIntOverflowModels
			}
			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: ParticipantRequestDecline: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParticipantRequestDecline: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotificationParticipantPermissionsChange) 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 ErrIntOverflowModels
			}
			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: ParticipantPermissionsChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParticipantPermissionsChange: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= ParticipantPermissions(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Export) 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 ErrIntOverflowModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Import) 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 ErrIntOverflowModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Invite) 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 ErrIntOverflowModels
			}
			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: Invite: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Invite: 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 byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InvitePayload) 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 ErrIntOverflowModels
			}
			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: InvitePayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InvitePayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatorIdentity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreatorIdentity = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatorName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreatorName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AclKey = append(m.AclKey[:0], dAtA[iNdEx:postIndex]...)
			if m.AclKey == nil {
				m.AclKey = []byte{}
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceIconCid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceIconCid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceIconEncryptionKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceIconEncryptionKeys = append(m.SpaceIconEncryptionKeys, &FileEncryptionKey{})
			if err := m.SpaceIconEncryptionKeys[len(m.SpaceIconEncryptionKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteType", wireType)
			}
			m.InviteType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InviteType |= InviteType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GuestKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GuestKey = append(m.GuestKey[:0], dAtA[iNdEx:postIndex]...)
			if m.GuestKey == nil {
				m.GuestKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IdentityProfile) 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 ErrIntOverflowModels
			}
			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: IdentityProfile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdentityProfile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 IconCid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconCid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEncryptionKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconEncryptionKeys = append(m.IconEncryptionKeys, &FileEncryptionKey{})
			if err := m.IconEncryptionKeys[len(m.IconEncryptionKeys)-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 Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GlobalName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileInfo) 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 ErrIntOverflowModels
			}
			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: FileInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptionKeys = append(m.EncryptionKeys, &FileEncryptionKey{})
			if err := m.EncryptionKeys[len(m.EncryptionKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ManifestInfo) 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 ErrIntOverflowModels
			}
			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: ManifestInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ManifestInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schema = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Author = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.License = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Screenshots", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Screenshots = append(m.Screenshots, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownloadLink", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DownloadLink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileSize", wireType)
			}
			m.FileSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FileSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Language", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Language = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Membership) 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 ErrIntOverflowModels
			}
			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 {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tier", wireType)
			}
			m.Tier = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tier |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= MembershipStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateStarted", wireType)
			}
			m.DateStarted = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DateStarted |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateEnds", wireType)
			}
			m.DateEnds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DateEnds |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAutoRenew", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAutoRenew = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PaymentMethod", wireType)
			}
			m.PaymentMethod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PaymentMethod |= MembershipPaymentMethod(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NsName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NsName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NsNameType", wireType)
			}
			m.NsNameType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NsNameType |= NameserviceNameType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserEmail", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserEmail = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscribeToNewsletter", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SubscribeToNewsletter = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MembershipTierData) 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 ErrIntOverflowModels
			}
			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: MembershipTierData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MembershipTierData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint32(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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsTest", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsTest = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeriodType", wireType)
			}
			m.PeriodType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeriodType |= MembershipTierDataPeriodType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeriodValue", wireType)
			}
			m.PeriodValue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeriodValue |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceStripeUsdCents", wireType)
			}
			m.PriceStripeUsdCents = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PriceStripeUsdCents |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnyNamesCountIncluded", wireType)
			}
			m.AnyNamesCountIncluded = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AnyNamesCountIncluded |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnyNameMinLength", wireType)
			}
			m.AnyNameMinLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AnyNameMinLength |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Features", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Features = append(m.Features, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColorStr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColorStr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StripeProductId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StripeProductId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StripeManageUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StripeManageUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IosProductId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IosProductId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IosManageUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IosManageUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AndroidProductId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AndroidProductId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AndroidManageUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AndroidManageUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Offer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Detail) 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 ErrIntOverflowModels
			}
			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: Detail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Detail: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeviceInfo) 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 ErrIntOverflowModels
			}
			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: DeviceInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeviceInfo: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddDate", wireType)
			}
			m.AddDate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddDate |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Archived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Archived = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsConnected", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsConnected = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChatState) 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 ErrIntOverflowModels
			}
			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: ChatState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChatState: 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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Messages == nil {
				m.Messages = &ChatStateUnreadState{}
			}
			if err := m.Messages.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mentions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Mentions == nil {
				m.Mentions = &ChatStateUnreadState{}
			}
			if err := m.Mentions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastStateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastStateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType)
			}
			m.Order = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Order |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChatMessage) 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 ErrIntOverflowModels
			}
			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: ChatMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChatMessage: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			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 Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplyToMessageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplyToMessageId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &ChatMessageMessageContent{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attachments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attachments = append(m.Attachments, &ChatMessageAttachment{})
			if err := m.Attachments[len(m.Attachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Reactions == nil {
				m.Reactions = &ChatMessageReactions{}
			}
			if err := m.Reactions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedAt", wireType)
			}
			m.ModifiedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModifiedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Read = bool(v != 0)
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MentionRead", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MentionRead = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Synced", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Synced = bool(v != 0)
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasMention", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasMention = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChatMessageMessageContent) 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 ErrIntOverflowModels
			}
			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: MessageContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Marks = append(m.Marks, &BlockContentTextMark{})
			if err := m.Marks[len(m.Marks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChatMessageReactions) 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 ErrIntOverflowModels
			}
			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: Reactions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Reactions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowModels
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthModels
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Reactions == nil {
				m.Reactions = make(map[string]*ChatMessageReactionsIdentityList)
			}
			var mapkey string
			var mapvalue *ChatMessageReactionsIdentityList
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowModels
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowModels
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthModels
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthModels
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowModels
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthModels
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthModels
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ChatMessageReactionsIdentityList{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipModels(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthModels
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Reactions[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChatMessageReactionsIdentityList) 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 ErrIntOverflowModels
			}
			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: IdentityList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdentityList: 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 ErrIntOverflowModels
				}
				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 ErrInvalidLengthModels
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthModels
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipModels(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthModels
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipModels(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, ErrIntOverflowModels
			}
			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, ErrIntOverflowModels
				}
				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, ErrIntOverflowModels
				}
				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, ErrInvalidLengthModels
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupModels
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthModels
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthModels        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowModels          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupModels = fmt.Errorf("proto: unexpected end of group")
)
