From 8e7dc9a2c97605e70ed0ac94715fe9ab2510e204 Mon Sep 17 00:00:00 2001 From: Kirill Date: Wed, 6 Nov 2019 19:50:31 +0100 Subject: [PATCH] Refactor: change block types --- docs/proto.md | 367 ++++-- pb/changes.pb.go | 2278 ++++++++++++++++++++++++++++---------- pb/commands.pb.go | 314 +++--- pb/events.pb.go | 79 +- pb/models.pb.go | 2202 ++++++++++++++++++++---------------- pb/protos/commands.proto | 4 +- pb/protos/events.proto | 2 +- 7 files changed, 3380 insertions(+), 1866 deletions(-) diff --git a/docs/proto.md b/docs/proto.md index c4820b675..0b0e5d0bb 100644 --- a/docs/proto.md +++ b/docs/proto.md @@ -11,17 +11,22 @@ - [changes.proto](#changes.proto) - - [BlockChanges](#anytype.BlockChanges) - - [BlocksListSingleChange](#anytype.BlocksListSingleChange) - [Change](#anytype.Change) - [Change.Block](#anytype.Change.Block) - [Change.Block.Children](#anytype.Change.Block.Children) - [Change.Block.Content](#anytype.Change.Block.Content) - [Change.Block.Content.Dashboard](#anytype.Change.Block.Content.Dashboard) - - [Change.Block.Content.Media](#anytype.Change.Block.Content.Media) + - [Change.Block.Content.File](#anytype.Change.Block.Content.File) + - [Change.Block.Content.Image](#anytype.Change.Block.Content.Image) - [Change.Block.Content.Page](#anytype.Change.Block.Content.Page) - [Change.Block.Content.Text](#anytype.Change.Block.Content.Text) - - [Change.Block.Header](#anytype.Change.Block.Header) + - [Change.Block.Content.Video](#anytype.Change.Block.Content.Video) + - [Change.Block.Fields](#anytype.Change.Block.Fields) + - [Change.Block.Permissions](#anytype.Change.Block.Permissions) + - [Change.Multiple](#anytype.Change.Multiple) + - [Change.Multiple.BlocksList](#anytype.Change.Multiple.BlocksList) + - [Change.Single](#anytype.Change.Single) + - [Change.Single.BlocksList](#anytype.Change.Single.BlocksList) @@ -144,17 +149,18 @@ - [Model.Block.Content.Dashboard](#anytype.Model.Block.Content.Dashboard) - [Model.Block.Content.Dataview](#anytype.Model.Block.Content.Dataview) - [Model.Block.Content.Div](#anytype.Model.Block.Content.Div) + - [Model.Block.Content.File](#anytype.Model.Block.Content.File) + - [Model.Block.Content.File.Preview](#anytype.Model.Block.Content.File.Preview) + - [Model.Block.Content.Image](#anytype.Model.Block.Content.Image) + - [Model.Block.Content.Image.Preview](#anytype.Model.Block.Content.Image.Preview) - [Model.Block.Content.Layout](#anytype.Model.Block.Content.Layout) - - [Model.Block.Content.Media](#anytype.Model.Block.Content.Media) - - [Model.Block.Content.Media.FilePreview](#anytype.Model.Block.Content.Media.FilePreview) - - [Model.Block.Content.Media.ImagePreview](#anytype.Model.Block.Content.Media.ImagePreview) - - [Model.Block.Content.Media.VideoPreview](#anytype.Model.Block.Content.Media.VideoPreview) - [Model.Block.Content.Page](#anytype.Model.Block.Content.Page) - [Model.Block.Content.Text](#anytype.Model.Block.Content.Text) - [Model.Block.Content.Text.Mark](#anytype.Model.Block.Content.Text.Mark) - [Model.Block.Content.Text.Marks](#anytype.Model.Block.Content.Text.Marks) - - [Model.Block.Header](#anytype.Model.Block.Header) - - [Model.Block.Header.Permissions](#anytype.Model.Block.Header.Permissions) + - [Model.Block.Content.Video](#anytype.Model.Block.Content.Video) + - [Model.Block.Content.Video.Preview](#anytype.Model.Block.Content.Video.Preview) + - [Model.Block.Permissions](#anytype.Model.Block.Permissions) - [Model.Image](#anytype.Model.Image) - [Model.Range](#anytype.Model.Range) - [Model.Struct](#anytype.Model.Struct) @@ -164,13 +170,15 @@ - [Model.Video](#anytype.Model.Video) - [Model.Block.Content.Dashboard.Style](#anytype.Model.Block.Content.Dashboard.Style) + - [Model.Block.Content.File.State](#anytype.Model.Block.Content.File.State) + - [Model.Block.Content.Image.State](#anytype.Model.Block.Content.Image.State) - [Model.Block.Content.Layout.Style](#anytype.Model.Block.Content.Layout.Style) - - [Model.Block.Content.Media.State](#anytype.Model.Block.Content.Media.State) - [Model.Block.Content.Page.Style](#anytype.Model.Block.Content.Page.Style) - [Model.Block.Content.Text.Mark.Type](#anytype.Model.Block.Content.Text.Mark.Type) - [Model.Block.Content.Text.MarkerType](#anytype.Model.Block.Content.Text.MarkerType) - [Model.Block.Content.Text.Style](#anytype.Model.Block.Content.Text.Style) - - [Model.Block.Header.Type](#anytype.Model.Block.Header.Type) + - [Model.Block.Content.Video.State](#anytype.Model.Block.Content.Video.State) + - [Model.Block.Type](#anytype.Model.Block.Type) - [Model.Image.Size](#anytype.Model.Image.Size) - [Model.Struct.NullValue](#anytype.Model.Struct.NullValue) - [Model.Video.Size](#anytype.Model.Video.Size) @@ -226,42 +234,6 @@ - - -### BlockChanges - - - -| Field | Type | Label | Description | -| ----- | ---- | ----- | ----------- | -| changes | [BlocksListSingleChange](#anytype.BlocksListSingleChange) | repeated | | - - - - - - - - -### BlocksListSingleChange - - - -| Field | Type | Label | Description | -| ----- | ---- | ----- | ----------- | -| id | [string](#string) | repeated | | -| text | [Change.Block.Content.Text](#anytype.Change.Block.Content.Text) | | | -| blockHeader | [Change.Block.Header](#anytype.Change.Block.Header) | | | -| blockChildren | [Change.Block.Children](#anytype.Change.Block.Children) | | | -| page | [Change.Block.Content.Page](#anytype.Change.Block.Content.Page) | | | -| dashboard | [Change.Block.Content.Dashboard](#anytype.Change.Block.Content.Dashboard) | | | -| media | [Change.Block.Content.Media](#anytype.Change.Block.Content.Media) | | | - - - - - - ### Change @@ -316,23 +288,41 @@ | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | style | [Model.Block.Content.Dashboard.Style](#anytype.Model.Block.Content.Dashboard.Style) | | | -| header | [Model.Block.Header](#anytype.Model.Block.Header) | | not a dashboard header – one of children | +| block | [Model.Block](#anytype.Model.Block) | | | - + -### Change.Block.Content.Media +### Change.Block.Content.File | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| link | [string](#string) | | | -| state | [Model.Block.Content.Media.State](#anytype.Model.Block.Content.Media.State) | | | +| content | [string](#string) | | | +| state | [Model.Block.Content.File.State](#anytype.Model.Block.Content.File.State) | | | +| preview | [Model.Block.Content.File.Preview](#anytype.Model.Block.Content.File.Preview) | | | + + + + + + + + +### Change.Block.Content.Image + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| content | [string](#string) | | | +| state | [Model.Block.Content.Image.State](#anytype.Model.Block.Content.Image.State) | | | +| preview | [Model.Block.Content.Image.Preview](#anytype.Model.Block.Content.Image.Preview) | | | @@ -376,19 +366,106 @@ - + -### Change.Block.Header +### Change.Block.Content.Video | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| id | [string](#string) | | | -| type | [Model.Block.Header.Type](#anytype.Model.Block.Header.Type) | | | -| name | [string](#string) | | | -| icon | [string](#string) | | | -| permissions | [Model.Block.Header.Permissions](#anytype.Model.Block.Header.Permissions) | | | +| content | [string](#string) | | | +| state | [Model.Block.Content.Video.State](#anytype.Model.Block.Content.Video.State) | | | +| preview | [Model.Block.Content.Video.Preview](#anytype.Model.Block.Content.Video.Preview) | | | + + + + + + + + +### Change.Block.Fields + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| fields | [Model.Struct](#anytype.Model.Struct) | | | + + + + + + + + +### Change.Block.Permissions + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| permissions | [Model.Block.Permissions](#anytype.Model.Block.Permissions) | | | + + + + + + + + +### Change.Multiple + + + + + + + + + +### Change.Multiple.BlocksList + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| changes | [Change.Single.BlocksList](#anytype.Change.Single.BlocksList) | repeated | | + + + + + + + + +### Change.Single + + + + + + + + + +### Change.Single.BlocksList + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| id | [string](#string) | repeated | | +| text | [Change.Block.Content.Text](#anytype.Change.Block.Content.Text) | | | +| fields | [Change.Block.Fields](#anytype.Change.Block.Fields) | | | +| premissions | [Change.Block.Permissions](#anytype.Change.Block.Permissions) | | | +| children | [Change.Block.Children](#anytype.Change.Block.Children) | | | +| page | [Change.Block.Content.Page](#anytype.Change.Block.Content.Page) | | | +| dashboard | [Change.Block.Content.Dashboard](#anytype.Change.Block.Content.Dashboard) | | | +| video | [Change.Block.Content.Video](#anytype.Change.Block.Content.Video) | | | +| image | [Change.Block.Content.Image](#anytype.Change.Block.Content.Image) | | | +| file | [Change.Block.Content.File](#anytype.Change.Block.Content.File) | | | @@ -629,7 +706,7 @@ Middleware-to-front-end response for an account select request, that can contain | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| type | [Model.Block.Header.Type](#anytype.Model.Block.Header.Type) | | | +| block | [Model.Block](#anytype.Model.Block) | | | | contextBlockId | [string](#string) | | | @@ -770,7 +847,6 @@ Middleware-to-front-end response for an account select request, that can contain | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | error | [Rpc.Block.Open.Response.Error](#anytype.Rpc.Block.Open.Response.Error) | | | -| blockHeader | [Model.Block.Header](#anytype.Model.Block.Header) | | | @@ -811,7 +887,7 @@ Middleware-to-front-end response for an account select request, that can contain | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| changes | [BlockChanges](#anytype.BlockChanges) | | | +| changes | [Change.Multiple.BlocksList](#anytype.Change.Multiple.BlocksList) | | | @@ -1675,7 +1751,7 @@ Precondition: user A opened a block | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| changes | [BlockChanges](#anytype.BlockChanges) | | | +| changes | [Change.Multiple.BlocksList](#anytype.Change.Multiple.BlocksList) | | | @@ -1844,13 +1920,17 @@ Avatar of a user's account. It could be an image or color | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| header | [Model.Block.Header](#anytype.Model.Block.Header) | | | +| id | [string](#string) | | | +| fields | [Model.Struct](#anytype.Model.Struct) | | | +| permissions | [Model.Block.Permissions](#anytype.Model.Block.Permissions) | | | | children | [string](#string) | repeated | | | dashboard | [Model.Block.Content.Dashboard](#anytype.Model.Block.Content.Dashboard) | | | | page | [Model.Block.Content.Page](#anytype.Model.Block.Content.Page) | | | | dataview | [Model.Block.Content.Dataview](#anytype.Model.Block.Content.Dataview) | | | | text | [Model.Block.Content.Text](#anytype.Model.Block.Content.Text) | | | -| media | [Model.Block.Content.Media](#anytype.Model.Block.Content.Media) | | | +| video | [Model.Block.Content.Video](#anytype.Model.Block.Content.Video) | | | +| image | [Model.Block.Content.Image](#anytype.Model.Block.Content.Image) | | | +| file | [Model.Block.Content.File](#anytype.Model.Block.Content.File) | | | | layout | [Model.Block.Content.Layout](#anytype.Model.Block.Content.Layout) | | | | div | [Model.Block.Content.Div](#anytype.Model.Block.Content.Div) | | | @@ -1878,7 +1958,6 @@ Avatar of a user's account. It could be an image or color | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | style | [Model.Block.Content.Dashboard.Style](#anytype.Model.Block.Content.Dashboard.Style) | | | -| headers | [Model.Block.Header](#anytype.Model.Block.Header) | repeated | | @@ -1905,43 +1984,26 @@ Avatar of a user's account. It could be an image or color - + -### Model.Block.Content.Layout +### Model.Block.Content.File | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| style | [Model.Block.Content.Layout.Style](#anytype.Model.Block.Content.Layout.Style) | | | +| content | [string](#string) | | | +| state | [Model.Block.Content.File.State](#anytype.Model.Block.Content.File.State) | | | +| preview | [Model.Block.Content.File.Preview](#anytype.Model.Block.Content.File.Preview) | | | - + -### Model.Block.Content.Media - - - -| Field | Type | Label | Description | -| ----- | ---- | ----- | ----------- | -| content | [bytes](#bytes) | | | -| state | [Model.Block.Content.Media.State](#anytype.Model.Block.Content.Media.State) | | | -| video | [Model.Block.Content.Media.VideoPreview](#anytype.Model.Block.Content.Media.VideoPreview) | | | -| image | [Model.Block.Content.Media.ImagePreview](#anytype.Model.Block.Content.Media.ImagePreview) | | | -| file | [Model.Block.Content.Media.FilePreview](#anytype.Model.Block.Content.Media.FilePreview) | | | - - - - - - - - -### Model.Block.Content.Media.FilePreview +### Model.Block.Content.File.Preview @@ -1955,9 +2017,26 @@ Avatar of a user's account. It could be an image or color - + -### Model.Block.Content.Media.ImagePreview +### Model.Block.Content.Image + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| content | [string](#string) | | | +| state | [Model.Block.Content.Image.State](#anytype.Model.Block.Content.Image.State) | | | +| preview | [Model.Block.Content.Image.Preview](#anytype.Model.Block.Content.Image.Preview) | | | + + + + + + + + +### Model.Block.Content.Image.Preview @@ -1972,17 +2051,15 @@ Avatar of a user's account. It could be an image or color - + -### Model.Block.Content.Media.VideoPreview +### Model.Block.Content.Layout | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| thumbnail | [bytes](#bytes) | | | -| name | [string](#string) | | | -| width | [int32](#int32) | | | +| style | [Model.Block.Content.Layout.Style](#anytype.Model.Block.Content.Layout.Style) | | | @@ -2057,27 +2134,43 @@ Avatar of a user's account. It could be an image or color - + -### Model.Block.Header +### Model.Block.Content.Video | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| id | [string](#string) | | | -| type | [Model.Block.Header.Type](#anytype.Model.Block.Header.Type) | | | -| fields | [Model.Struct](#anytype.Model.Struct) | | | -| permissions | [Model.Block.Header.Permissions](#anytype.Model.Block.Header.Permissions) | | | +| content | [string](#string) | | | +| state | [Model.Block.Content.Video.State](#anytype.Model.Block.Content.Video.State) | | | +| preview | [Model.Block.Content.Video.Preview](#anytype.Model.Block.Content.Video.Preview) | | | - + -### Model.Block.Header.Permissions +### Model.Block.Content.Video.Preview + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| thumbnail | [bytes](#bytes) | | | +| name | [string](#string) | | | +| width | [int32](#int32) | | | + + + + + + + + +### Model.Block.Permissions @@ -2224,21 +2317,9 @@ variants, absence of any variant indicates an error. - + -### Model.Block.Content.Layout.Style - - -| Name | Number | Description | -| ---- | ------ | ----------- | -| ROW | 0 | | -| COLUMN | 1 | | - - - - - -### Model.Block.Content.Media.State +### Model.Block.Content.File.State | Name | Number | Description | @@ -2251,6 +2332,33 @@ variants, absence of any variant indicates an error. + + +### Model.Block.Content.Image.State + + +| Name | Number | Description | +| ---- | ------ | ----------- | +| EMPTY | 0 | | +| UPLOADING | 1 | | +| PREVIEW | 2 | | +| DOWNLOADING | 3 | | +| DONE | 4 | | + + + + + +### Model.Block.Content.Layout.Style + + +| Name | Number | Description | +| ---- | ------ | ----------- | +| ROW | 0 | | +| COLUMN | 1 | | + + + ### Model.Block.Content.Page.Style @@ -2310,9 +2418,24 @@ variants, absence of any variant indicates an error. - + -### Model.Block.Header.Type +### Model.Block.Content.Video.State + + +| Name | Number | Description | +| ---- | ------ | ----------- | +| EMPTY | 0 | | +| UPLOADING | 1 | | +| PREVIEW | 2 | | +| DOWNLOADING | 3 | | +| DONE | 4 | | + + + + + +### Model.Block.Type | Name | Number | Description | diff --git a/pb/changes.pb.go b/pb/changes.pb.go index f12f3fc99..dcc28b231 100644 --- a/pb/changes.pb.go +++ b/pb/changes.pb.go @@ -94,28 +94,22 @@ func (m *ChangeBlock) XXX_DiscardUnknown() { var xxx_messageInfo_ChangeBlock proto.InternalMessageInfo -type ChangeBlockHeader struct { - // Types that are valid to be assigned to Change: - // *ChangeBlockHeaderChangeOfId - // *ChangeBlockHeaderChangeOfType - // *ChangeBlockHeaderChangeOfName - // *ChangeBlockHeaderChangeOfIcon - // *ChangeBlockHeaderChangeOfPermissions - Change isChangeBlockHeaderChange `protobuf_oneof:"change"` +type ChangeBlockFields struct { + Fields *ModelStruct `protobuf:"bytes,1,opt,name=fields,proto3" json:"fields,omitempty"` } -func (m *ChangeBlockHeader) Reset() { *m = ChangeBlockHeader{} } -func (m *ChangeBlockHeader) String() string { return proto.CompactTextString(m) } -func (*ChangeBlockHeader) ProtoMessage() {} -func (*ChangeBlockHeader) Descriptor() ([]byte, []int) { +func (m *ChangeBlockFields) Reset() { *m = ChangeBlockFields{} } +func (m *ChangeBlockFields) String() string { return proto.CompactTextString(m) } +func (*ChangeBlockFields) ProtoMessage() {} +func (*ChangeBlockFields) Descriptor() ([]byte, []int) { return fileDescriptor_b16a38c6509bd894, []int{0, 0, 0} } -func (m *ChangeBlockHeader) XXX_Unmarshal(b []byte) error { +func (m *ChangeBlockFields) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ChangeBlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ChangeBlockFields) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ChangeBlockHeader.Marshal(b, m, deterministic) + return xxx_messageInfo_ChangeBlockFields.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -125,99 +119,69 @@ func (m *ChangeBlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } -func (m *ChangeBlockHeader) XXX_Merge(src proto.Message) { - xxx_messageInfo_ChangeBlockHeader.Merge(m, src) +func (m *ChangeBlockFields) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeBlockFields.Merge(m, src) } -func (m *ChangeBlockHeader) XXX_Size() int { +func (m *ChangeBlockFields) XXX_Size() int { return m.Size() } -func (m *ChangeBlockHeader) XXX_DiscardUnknown() { - xxx_messageInfo_ChangeBlockHeader.DiscardUnknown(m) +func (m *ChangeBlockFields) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeBlockFields.DiscardUnknown(m) } -var xxx_messageInfo_ChangeBlockHeader proto.InternalMessageInfo +var xxx_messageInfo_ChangeBlockFields proto.InternalMessageInfo -type isChangeBlockHeaderChange interface { - isChangeBlockHeaderChange() - MarshalTo([]byte) (int, error) - Size() int -} - -type ChangeBlockHeaderChangeOfId struct { - Id string `protobuf:"bytes,1,opt,name=id,proto3,oneof" json:"id,omitempty"` -} -type ChangeBlockHeaderChangeOfType struct { - Type ModelBlockHeaderType `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.ModelBlockHeaderType,oneof" json:"type,omitempty"` -} -type ChangeBlockHeaderChangeOfName struct { - Name string `protobuf:"bytes,3,opt,name=name,proto3,oneof" json:"name,omitempty"` -} -type ChangeBlockHeaderChangeOfIcon struct { - Icon string `protobuf:"bytes,4,opt,name=icon,proto3,oneof" json:"icon,omitempty"` -} -type ChangeBlockHeaderChangeOfPermissions struct { - Permissions *ModelBlockHeaderPermissions `protobuf:"bytes,5,opt,name=permissions,proto3,oneof" json:"permissions,omitempty"` -} - -func (*ChangeBlockHeaderChangeOfId) isChangeBlockHeaderChange() {} -func (*ChangeBlockHeaderChangeOfType) isChangeBlockHeaderChange() {} -func (*ChangeBlockHeaderChangeOfName) isChangeBlockHeaderChange() {} -func (*ChangeBlockHeaderChangeOfIcon) isChangeBlockHeaderChange() {} -func (*ChangeBlockHeaderChangeOfPermissions) isChangeBlockHeaderChange() {} - -func (m *ChangeBlockHeader) GetChange() isChangeBlockHeaderChange { +func (m *ChangeBlockFields) GetFields() *ModelStruct { if m != nil { - return m.Change + return m.Fields } return nil } -func (m *ChangeBlockHeader) GetId() string { - if x, ok := m.GetChange().(*ChangeBlockHeaderChangeOfId); ok { - return x.Id - } - return "" +type ChangeBlockPermissions struct { + Permissions *ModelBlockPermissions `protobuf:"bytes,1,opt,name=permissions,proto3" json:"permissions,omitempty"` } -func (m *ChangeBlockHeader) GetType() ModelBlockHeaderType { - if x, ok := m.GetChange().(*ChangeBlockHeaderChangeOfType); ok { - return x.Type +func (m *ChangeBlockPermissions) Reset() { *m = ChangeBlockPermissions{} } +func (m *ChangeBlockPermissions) String() string { return proto.CompactTextString(m) } +func (*ChangeBlockPermissions) ProtoMessage() {} +func (*ChangeBlockPermissions) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 1} +} +func (m *ChangeBlockPermissions) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangeBlockPermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangeBlockPermissions.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return ModelBlockHeader_DASHBOARD +} +func (m *ChangeBlockPermissions) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeBlockPermissions.Merge(m, src) +} +func (m *ChangeBlockPermissions) XXX_Size() int { + return m.Size() +} +func (m *ChangeBlockPermissions) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeBlockPermissions.DiscardUnknown(m) } -func (m *ChangeBlockHeader) GetName() string { - if x, ok := m.GetChange().(*ChangeBlockHeaderChangeOfName); ok { - return x.Name - } - return "" -} +var xxx_messageInfo_ChangeBlockPermissions proto.InternalMessageInfo -func (m *ChangeBlockHeader) GetIcon() string { - if x, ok := m.GetChange().(*ChangeBlockHeaderChangeOfIcon); ok { - return x.Icon - } - return "" -} - -func (m *ChangeBlockHeader) GetPermissions() *ModelBlockHeaderPermissions { - if x, ok := m.GetChange().(*ChangeBlockHeaderChangeOfPermissions); ok { - return x.Permissions +func (m *ChangeBlockPermissions) GetPermissions() *ModelBlockPermissions { + if m != nil { + return m.Permissions } return nil } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ChangeBlockHeader) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ChangeBlockHeaderChangeOfId)(nil), - (*ChangeBlockHeaderChangeOfType)(nil), - (*ChangeBlockHeaderChangeOfName)(nil), - (*ChangeBlockHeaderChangeOfIcon)(nil), - (*ChangeBlockHeaderChangeOfPermissions)(nil), - } -} - type ChangeBlockChildren struct { Children []string `protobuf:"bytes,1,rep,name=children,proto3" json:"children,omitempty"` } @@ -226,7 +190,7 @@ func (m *ChangeBlockChildren) Reset() { *m = ChangeBlockChildren{} } func (m *ChangeBlockChildren) String() string { return proto.CompactTextString(m) } func (*ChangeBlockChildren) ProtoMessage() {} func (*ChangeBlockChildren) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{0, 0, 1} + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 2} } func (m *ChangeBlockChildren) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -269,7 +233,7 @@ func (m *ChangeBlockContent) Reset() { *m = ChangeBlockContent{} } func (m *ChangeBlockContent) String() string { return proto.CompactTextString(m) } func (*ChangeBlockContent) ProtoMessage() {} func (*ChangeBlockContent) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{0, 0, 2} + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3} } func (m *ChangeBlockContent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -309,7 +273,7 @@ func (m *ChangeBlockContentPage) Reset() { *m = ChangeBlockContentPage{} func (m *ChangeBlockContentPage) String() string { return proto.CompactTextString(m) } func (*ChangeBlockContentPage) ProtoMessage() {} func (*ChangeBlockContentPage) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{0, 0, 2, 0} + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3, 0} } func (m *ChangeBlockContentPage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -386,7 +350,7 @@ func (*ChangeBlockContentPage) XXX_OneofWrappers() []interface{} { type ChangeBlockContentDashboard struct { // Types that are valid to be assigned to Change: // *ChangeBlockContentDashboardChangeOfStyle - // *ChangeBlockContentDashboardChangeOfHeader + // *ChangeBlockContentDashboardChangeOfBlock Change isChangeBlockContentDashboardChange `protobuf_oneof:"change"` } @@ -394,7 +358,7 @@ func (m *ChangeBlockContentDashboard) Reset() { *m = ChangeBlockContentD func (m *ChangeBlockContentDashboard) String() string { return proto.CompactTextString(m) } func (*ChangeBlockContentDashboard) ProtoMessage() {} func (*ChangeBlockContentDashboard) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{0, 0, 2, 1} + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3, 1} } func (m *ChangeBlockContentDashboard) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -432,12 +396,12 @@ type isChangeBlockContentDashboardChange interface { type ChangeBlockContentDashboardChangeOfStyle struct { Style ModelBlockContentDashboardStyle `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.ModelBlockContentDashboardStyle,oneof" json:"style,omitempty"` } -type ChangeBlockContentDashboardChangeOfHeader struct { - Header *ModelBlockHeader `protobuf:"bytes,2,opt,name=header,proto3,oneof" json:"header,omitempty"` +type ChangeBlockContentDashboardChangeOfBlock struct { + Block *ModelBlock `protobuf:"bytes,2,opt,name=block,proto3,oneof" json:"block,omitempty"` } -func (*ChangeBlockContentDashboardChangeOfStyle) isChangeBlockContentDashboardChange() {} -func (*ChangeBlockContentDashboardChangeOfHeader) isChangeBlockContentDashboardChange() {} +func (*ChangeBlockContentDashboardChangeOfStyle) isChangeBlockContentDashboardChange() {} +func (*ChangeBlockContentDashboardChangeOfBlock) isChangeBlockContentDashboardChange() {} func (m *ChangeBlockContentDashboard) GetChange() isChangeBlockContentDashboardChange { if m != nil { @@ -453,9 +417,9 @@ func (m *ChangeBlockContentDashboard) GetStyle() ModelBlockContentDashboardStyle return ModelBlockContentDashboard_MAIN_SCREEN } -func (m *ChangeBlockContentDashboard) GetHeader() *ModelBlockHeader { - if x, ok := m.GetChange().(*ChangeBlockContentDashboardChangeOfHeader); ok { - return x.Header +func (m *ChangeBlockContentDashboard) GetBlock() *ModelBlock { + if x, ok := m.GetChange().(*ChangeBlockContentDashboardChangeOfBlock); ok { + return x.Block } return nil } @@ -464,29 +428,30 @@ func (m *ChangeBlockContentDashboard) GetHeader() *ModelBlockHeader { func (*ChangeBlockContentDashboard) XXX_OneofWrappers() []interface{} { return []interface{}{ (*ChangeBlockContentDashboardChangeOfStyle)(nil), - (*ChangeBlockContentDashboardChangeOfHeader)(nil), + (*ChangeBlockContentDashboardChangeOfBlock)(nil), } } -type ChangeBlockContentMedia struct { +type ChangeBlockContentFile struct { // Types that are valid to be assigned to Change: - // *ChangeBlockContentMediaChangeOfLink - // *ChangeBlockContentMediaChangeOfState - Change isChangeBlockContentMediaChange `protobuf_oneof:"change"` + // *ChangeBlockContentFileChangeOfContent + // *ChangeBlockContentFileChangeOfState + // *ChangeBlockContentFileChangeOfPreview + Change isChangeBlockContentFileChange `protobuf_oneof:"change"` } -func (m *ChangeBlockContentMedia) Reset() { *m = ChangeBlockContentMedia{} } -func (m *ChangeBlockContentMedia) String() string { return proto.CompactTextString(m) } -func (*ChangeBlockContentMedia) ProtoMessage() {} -func (*ChangeBlockContentMedia) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{0, 0, 2, 2} +func (m *ChangeBlockContentFile) Reset() { *m = ChangeBlockContentFile{} } +func (m *ChangeBlockContentFile) String() string { return proto.CompactTextString(m) } +func (*ChangeBlockContentFile) ProtoMessage() {} +func (*ChangeBlockContentFile) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3, 2} } -func (m *ChangeBlockContentMedia) XXX_Unmarshal(b []byte) error { +func (m *ChangeBlockContentFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ChangeBlockContentMedia) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ChangeBlockContentFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ChangeBlockContentMedia.Marshal(b, m, deterministic) + return xxx_messageInfo_ChangeBlockContentFile.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -496,60 +461,268 @@ func (m *ChangeBlockContentMedia) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } -func (m *ChangeBlockContentMedia) XXX_Merge(src proto.Message) { - xxx_messageInfo_ChangeBlockContentMedia.Merge(m, src) +func (m *ChangeBlockContentFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeBlockContentFile.Merge(m, src) } -func (m *ChangeBlockContentMedia) XXX_Size() int { +func (m *ChangeBlockContentFile) XXX_Size() int { return m.Size() } -func (m *ChangeBlockContentMedia) XXX_DiscardUnknown() { - xxx_messageInfo_ChangeBlockContentMedia.DiscardUnknown(m) +func (m *ChangeBlockContentFile) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeBlockContentFile.DiscardUnknown(m) } -var xxx_messageInfo_ChangeBlockContentMedia proto.InternalMessageInfo +var xxx_messageInfo_ChangeBlockContentFile proto.InternalMessageInfo -type isChangeBlockContentMediaChange interface { - isChangeBlockContentMediaChange() +type isChangeBlockContentFileChange interface { + isChangeBlockContentFileChange() MarshalTo([]byte) (int, error) Size() int } -type ChangeBlockContentMediaChangeOfLink struct { - Link string `protobuf:"bytes,1,opt,name=link,proto3,oneof" json:"link,omitempty"` +type ChangeBlockContentFileChangeOfContent struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3,oneof" json:"content,omitempty"` } -type ChangeBlockContentMediaChangeOfState struct { - State ModelBlockContentMediaState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentMediaState,oneof" json:"state,omitempty"` +type ChangeBlockContentFileChangeOfState struct { + State ModelBlockContentFileState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentFileState,oneof" json:"state,omitempty"` +} +type ChangeBlockContentFileChangeOfPreview struct { + Preview *ModelBlockContentFilePreview `protobuf:"bytes,3,opt,name=preview,proto3,oneof" json:"preview,omitempty"` } -func (*ChangeBlockContentMediaChangeOfLink) isChangeBlockContentMediaChange() {} -func (*ChangeBlockContentMediaChangeOfState) isChangeBlockContentMediaChange() {} +func (*ChangeBlockContentFileChangeOfContent) isChangeBlockContentFileChange() {} +func (*ChangeBlockContentFileChangeOfState) isChangeBlockContentFileChange() {} +func (*ChangeBlockContentFileChangeOfPreview) isChangeBlockContentFileChange() {} -func (m *ChangeBlockContentMedia) GetChange() isChangeBlockContentMediaChange { +func (m *ChangeBlockContentFile) GetChange() isChangeBlockContentFileChange { if m != nil { return m.Change } return nil } -func (m *ChangeBlockContentMedia) GetLink() string { - if x, ok := m.GetChange().(*ChangeBlockContentMediaChangeOfLink); ok { - return x.Link +func (m *ChangeBlockContentFile) GetContent() string { + if x, ok := m.GetChange().(*ChangeBlockContentFileChangeOfContent); ok { + return x.Content } return "" } -func (m *ChangeBlockContentMedia) GetState() ModelBlockContentMediaState { - if x, ok := m.GetChange().(*ChangeBlockContentMediaChangeOfState); ok { +func (m *ChangeBlockContentFile) GetState() ModelBlockContentFileState { + if x, ok := m.GetChange().(*ChangeBlockContentFileChangeOfState); ok { return x.State } - return ModelBlockContentMedia_EMPTY + return ModelBlockContentFile_EMPTY +} + +func (m *ChangeBlockContentFile) GetPreview() *ModelBlockContentFilePreview { + if x, ok := m.GetChange().(*ChangeBlockContentFileChangeOfPreview); ok { + return x.Preview + } + return nil } // XXX_OneofWrappers is for the internal use of the proto package. -func (*ChangeBlockContentMedia) XXX_OneofWrappers() []interface{} { +func (*ChangeBlockContentFile) XXX_OneofWrappers() []interface{} { return []interface{}{ - (*ChangeBlockContentMediaChangeOfLink)(nil), - (*ChangeBlockContentMediaChangeOfState)(nil), + (*ChangeBlockContentFileChangeOfContent)(nil), + (*ChangeBlockContentFileChangeOfState)(nil), + (*ChangeBlockContentFileChangeOfPreview)(nil), + } +} + +type ChangeBlockContentImage struct { + // Types that are valid to be assigned to Change: + // *ChangeBlockContentImageChangeOfContent + // *ChangeBlockContentImageChangeOfState + // *ChangeBlockContentImageChangeOfPreview + Change isChangeBlockContentImageChange `protobuf_oneof:"change"` +} + +func (m *ChangeBlockContentImage) Reset() { *m = ChangeBlockContentImage{} } +func (m *ChangeBlockContentImage) String() string { return proto.CompactTextString(m) } +func (*ChangeBlockContentImage) ProtoMessage() {} +func (*ChangeBlockContentImage) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3, 3} +} +func (m *ChangeBlockContentImage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangeBlockContentImage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangeBlockContentImage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ChangeBlockContentImage) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeBlockContentImage.Merge(m, src) +} +func (m *ChangeBlockContentImage) XXX_Size() int { + return m.Size() +} +func (m *ChangeBlockContentImage) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeBlockContentImage.DiscardUnknown(m) +} + +var xxx_messageInfo_ChangeBlockContentImage proto.InternalMessageInfo + +type isChangeBlockContentImageChange interface { + isChangeBlockContentImageChange() + MarshalTo([]byte) (int, error) + Size() int +} + +type ChangeBlockContentImageChangeOfContent struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3,oneof" json:"content,omitempty"` +} +type ChangeBlockContentImageChangeOfState struct { + State ModelBlockContentImageState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentImageState,oneof" json:"state,omitempty"` +} +type ChangeBlockContentImageChangeOfPreview struct { + Preview *ModelBlockContentImagePreview `protobuf:"bytes,3,opt,name=preview,proto3,oneof" json:"preview,omitempty"` +} + +func (*ChangeBlockContentImageChangeOfContent) isChangeBlockContentImageChange() {} +func (*ChangeBlockContentImageChangeOfState) isChangeBlockContentImageChange() {} +func (*ChangeBlockContentImageChangeOfPreview) isChangeBlockContentImageChange() {} + +func (m *ChangeBlockContentImage) GetChange() isChangeBlockContentImageChange { + if m != nil { + return m.Change + } + return nil +} + +func (m *ChangeBlockContentImage) GetContent() string { + if x, ok := m.GetChange().(*ChangeBlockContentImageChangeOfContent); ok { + return x.Content + } + return "" +} + +func (m *ChangeBlockContentImage) GetState() ModelBlockContentImageState { + if x, ok := m.GetChange().(*ChangeBlockContentImageChangeOfState); ok { + return x.State + } + return ModelBlockContentImage_EMPTY +} + +func (m *ChangeBlockContentImage) GetPreview() *ModelBlockContentImagePreview { + if x, ok := m.GetChange().(*ChangeBlockContentImageChangeOfPreview); ok { + return x.Preview + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ChangeBlockContentImage) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ChangeBlockContentImageChangeOfContent)(nil), + (*ChangeBlockContentImageChangeOfState)(nil), + (*ChangeBlockContentImageChangeOfPreview)(nil), + } +} + +type ChangeBlockContentVideo struct { + // Types that are valid to be assigned to Change: + // *ChangeBlockContentVideoChangeOfContent + // *ChangeBlockContentVideoChangeOfState + // *ChangeBlockContentVideoChangeOfPreview + Change isChangeBlockContentVideoChange `protobuf_oneof:"change"` +} + +func (m *ChangeBlockContentVideo) Reset() { *m = ChangeBlockContentVideo{} } +func (m *ChangeBlockContentVideo) String() string { return proto.CompactTextString(m) } +func (*ChangeBlockContentVideo) ProtoMessage() {} +func (*ChangeBlockContentVideo) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3, 4} +} +func (m *ChangeBlockContentVideo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangeBlockContentVideo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangeBlockContentVideo.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ChangeBlockContentVideo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeBlockContentVideo.Merge(m, src) +} +func (m *ChangeBlockContentVideo) XXX_Size() int { + return m.Size() +} +func (m *ChangeBlockContentVideo) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeBlockContentVideo.DiscardUnknown(m) +} + +var xxx_messageInfo_ChangeBlockContentVideo proto.InternalMessageInfo + +type isChangeBlockContentVideoChange interface { + isChangeBlockContentVideoChange() + MarshalTo([]byte) (int, error) + Size() int +} + +type ChangeBlockContentVideoChangeOfContent struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3,oneof" json:"content,omitempty"` +} +type ChangeBlockContentVideoChangeOfState struct { + State ModelBlockContentVideoState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentVideoState,oneof" json:"state,omitempty"` +} +type ChangeBlockContentVideoChangeOfPreview struct { + Preview *ModelBlockContentVideoPreview `protobuf:"bytes,3,opt,name=preview,proto3,oneof" json:"preview,omitempty"` +} + +func (*ChangeBlockContentVideoChangeOfContent) isChangeBlockContentVideoChange() {} +func (*ChangeBlockContentVideoChangeOfState) isChangeBlockContentVideoChange() {} +func (*ChangeBlockContentVideoChangeOfPreview) isChangeBlockContentVideoChange() {} + +func (m *ChangeBlockContentVideo) GetChange() isChangeBlockContentVideoChange { + if m != nil { + return m.Change + } + return nil +} + +func (m *ChangeBlockContentVideo) GetContent() string { + if x, ok := m.GetChange().(*ChangeBlockContentVideoChangeOfContent); ok { + return x.Content + } + return "" +} + +func (m *ChangeBlockContentVideo) GetState() ModelBlockContentVideoState { + if x, ok := m.GetChange().(*ChangeBlockContentVideoChangeOfState); ok { + return x.State + } + return ModelBlockContentVideo_EMPTY +} + +func (m *ChangeBlockContentVideo) GetPreview() *ModelBlockContentVideoPreview { + if x, ok := m.GetChange().(*ChangeBlockContentVideoChangeOfPreview); ok { + return x.Preview + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ChangeBlockContentVideo) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ChangeBlockContentVideoChangeOfContent)(nil), + (*ChangeBlockContentVideoChangeOfState)(nil), + (*ChangeBlockContentVideoChangeOfPreview)(nil), } } @@ -569,7 +742,7 @@ func (m *ChangeBlockContentText) Reset() { *m = ChangeBlockContentText{} func (m *ChangeBlockContentText) String() string { return proto.CompactTextString(m) } func (*ChangeBlockContentText) ProtoMessage() {} func (*ChangeBlockContentText) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{0, 0, 2, 3} + return fileDescriptor_b16a38c6509bd894, []int{0, 0, 3, 5} } func (m *ChangeBlockContentText) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -703,30 +876,21 @@ func (*ChangeBlockContentText) XXX_OneofWrappers() []interface{} { } } -type BlocksListSingleChange struct { - Id []string `protobuf:"bytes,1,rep,name=id,proto3" json:"id,omitempty"` - // Types that are valid to be assigned to Change: - // *BlocksListSingleChangeChangeOfText - // *BlocksListSingleChangeChangeOfBlockHeader - // *BlocksListSingleChangeChangeOfBlockChildren - // *BlocksListSingleChangeChangeOfPage - // *BlocksListSingleChangeChangeOfDashboard - // *BlocksListSingleChangeChangeOfMedia - Change isBlocksListSingleChangeChange `protobuf_oneof:"change"` +type ChangeSingle struct { } -func (m *BlocksListSingleChange) Reset() { *m = BlocksListSingleChange{} } -func (m *BlocksListSingleChange) String() string { return proto.CompactTextString(m) } -func (*BlocksListSingleChange) ProtoMessage() {} -func (*BlocksListSingleChange) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{1} +func (m *ChangeSingle) Reset() { *m = ChangeSingle{} } +func (m *ChangeSingle) String() string { return proto.CompactTextString(m) } +func (*ChangeSingle) ProtoMessage() {} +func (*ChangeSingle) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 1} } -func (m *BlocksListSingleChange) XXX_Unmarshal(b []byte) error { +func (m *ChangeSingle) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *BlocksListSingleChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ChangeSingle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_BlocksListSingleChange.Marshal(b, m, deterministic) + return xxx_messageInfo_ChangeSingle.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -736,134 +900,217 @@ func (m *BlocksListSingleChange) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } -func (m *BlocksListSingleChange) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlocksListSingleChange.Merge(m, src) +func (m *ChangeSingle) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeSingle.Merge(m, src) } -func (m *BlocksListSingleChange) XXX_Size() int { +func (m *ChangeSingle) XXX_Size() int { return m.Size() } -func (m *BlocksListSingleChange) XXX_DiscardUnknown() { - xxx_messageInfo_BlocksListSingleChange.DiscardUnknown(m) +func (m *ChangeSingle) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeSingle.DiscardUnknown(m) } -var xxx_messageInfo_BlocksListSingleChange proto.InternalMessageInfo +var xxx_messageInfo_ChangeSingle proto.InternalMessageInfo -type isBlocksListSingleChangeChange interface { - isBlocksListSingleChangeChange() +type ChangeSingleBlocksList struct { + Id []string `protobuf:"bytes,1,rep,name=id,proto3" json:"id,omitempty"` + // Types that are valid to be assigned to Change: + // *ChangeSingleBlocksListChangeOfText + // *ChangeSingleBlocksListChangeOfFields + // *ChangeSingleBlocksListChangeOfPremissions + // *ChangeSingleBlocksListChangeOfChildren + // *ChangeSingleBlocksListChangeOfPage + // *ChangeSingleBlocksListChangeOfDashboard + // *ChangeSingleBlocksListChangeOfVideo + // *ChangeSingleBlocksListChangeOfImage + // *ChangeSingleBlocksListChangeOfFile + Change isChangeSingleBlocksListChange `protobuf_oneof:"change"` +} + +func (m *ChangeSingleBlocksList) Reset() { *m = ChangeSingleBlocksList{} } +func (m *ChangeSingleBlocksList) String() string { return proto.CompactTextString(m) } +func (*ChangeSingleBlocksList) ProtoMessage() {} +func (*ChangeSingleBlocksList) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 1, 0} +} +func (m *ChangeSingleBlocksList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangeSingleBlocksList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangeSingleBlocksList.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ChangeSingleBlocksList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeSingleBlocksList.Merge(m, src) +} +func (m *ChangeSingleBlocksList) XXX_Size() int { + return m.Size() +} +func (m *ChangeSingleBlocksList) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeSingleBlocksList.DiscardUnknown(m) +} + +var xxx_messageInfo_ChangeSingleBlocksList proto.InternalMessageInfo + +type isChangeSingleBlocksListChange interface { + isChangeSingleBlocksListChange() MarshalTo([]byte) (int, error) Size() int } -type BlocksListSingleChangeChangeOfText struct { +type ChangeSingleBlocksListChangeOfText struct { Text *ChangeBlockContentText `protobuf:"bytes,2,opt,name=text,proto3,oneof" json:"text,omitempty"` } -type BlocksListSingleChangeChangeOfBlockHeader struct { - BlockHeader *ChangeBlockHeader `protobuf:"bytes,3,opt,name=blockHeader,proto3,oneof" json:"blockHeader,omitempty"` +type ChangeSingleBlocksListChangeOfFields struct { + Fields *ChangeBlockFields `protobuf:"bytes,3,opt,name=fields,proto3,oneof" json:"fields,omitempty"` } -type BlocksListSingleChangeChangeOfBlockChildren struct { - BlockChildren *ChangeBlockChildren `protobuf:"bytes,4,opt,name=blockChildren,proto3,oneof" json:"blockChildren,omitempty"` +type ChangeSingleBlocksListChangeOfPremissions struct { + Premissions *ChangeBlockPermissions `protobuf:"bytes,4,opt,name=premissions,proto3,oneof" json:"premissions,omitempty"` } -type BlocksListSingleChangeChangeOfPage struct { - Page *ChangeBlockContentPage `protobuf:"bytes,5,opt,name=page,proto3,oneof" json:"page,omitempty"` +type ChangeSingleBlocksListChangeOfChildren struct { + Children *ChangeBlockChildren `protobuf:"bytes,5,opt,name=children,proto3,oneof" json:"children,omitempty"` } -type BlocksListSingleChangeChangeOfDashboard struct { - Dashboard *ChangeBlockContentDashboard `protobuf:"bytes,6,opt,name=dashboard,proto3,oneof" json:"dashboard,omitempty"` +type ChangeSingleBlocksListChangeOfPage struct { + Page *ChangeBlockContentPage `protobuf:"bytes,6,opt,name=page,proto3,oneof" json:"page,omitempty"` } -type BlocksListSingleChangeChangeOfMedia struct { - Media *ChangeBlockContentMedia `protobuf:"bytes,7,opt,name=media,proto3,oneof" json:"media,omitempty"` +type ChangeSingleBlocksListChangeOfDashboard struct { + Dashboard *ChangeBlockContentDashboard `protobuf:"bytes,7,opt,name=dashboard,proto3,oneof" json:"dashboard,omitempty"` +} +type ChangeSingleBlocksListChangeOfVideo struct { + Video *ChangeBlockContentVideo `protobuf:"bytes,8,opt,name=video,proto3,oneof" json:"video,omitempty"` +} +type ChangeSingleBlocksListChangeOfImage struct { + Image *ChangeBlockContentImage `protobuf:"bytes,9,opt,name=image,proto3,oneof" json:"image,omitempty"` +} +type ChangeSingleBlocksListChangeOfFile struct { + File *ChangeBlockContentFile `protobuf:"bytes,10,opt,name=file,proto3,oneof" json:"file,omitempty"` } -func (*BlocksListSingleChangeChangeOfText) isBlocksListSingleChangeChange() {} -func (*BlocksListSingleChangeChangeOfBlockHeader) isBlocksListSingleChangeChange() {} -func (*BlocksListSingleChangeChangeOfBlockChildren) isBlocksListSingleChangeChange() {} -func (*BlocksListSingleChangeChangeOfPage) isBlocksListSingleChangeChange() {} -func (*BlocksListSingleChangeChangeOfDashboard) isBlocksListSingleChangeChange() {} -func (*BlocksListSingleChangeChangeOfMedia) isBlocksListSingleChangeChange() {} +func (*ChangeSingleBlocksListChangeOfText) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfFields) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfPremissions) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfChildren) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfPage) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfDashboard) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfVideo) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfImage) isChangeSingleBlocksListChange() {} +func (*ChangeSingleBlocksListChangeOfFile) isChangeSingleBlocksListChange() {} -func (m *BlocksListSingleChange) GetChange() isBlocksListSingleChangeChange { +func (m *ChangeSingleBlocksList) GetChange() isChangeSingleBlocksListChange { if m != nil { return m.Change } return nil } -func (m *BlocksListSingleChange) GetId() []string { +func (m *ChangeSingleBlocksList) GetId() []string { if m != nil { return m.Id } return nil } -func (m *BlocksListSingleChange) GetText() *ChangeBlockContentText { - if x, ok := m.GetChange().(*BlocksListSingleChangeChangeOfText); ok { +func (m *ChangeSingleBlocksList) GetText() *ChangeBlockContentText { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfText); ok { return x.Text } return nil } -func (m *BlocksListSingleChange) GetBlockHeader() *ChangeBlockHeader { - if x, ok := m.GetChange().(*BlocksListSingleChangeChangeOfBlockHeader); ok { - return x.BlockHeader +func (m *ChangeSingleBlocksList) GetFields() *ChangeBlockFields { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfFields); ok { + return x.Fields } return nil } -func (m *BlocksListSingleChange) GetBlockChildren() *ChangeBlockChildren { - if x, ok := m.GetChange().(*BlocksListSingleChangeChangeOfBlockChildren); ok { - return x.BlockChildren +func (m *ChangeSingleBlocksList) GetPremissions() *ChangeBlockPermissions { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfPremissions); ok { + return x.Premissions } return nil } -func (m *BlocksListSingleChange) GetPage() *ChangeBlockContentPage { - if x, ok := m.GetChange().(*BlocksListSingleChangeChangeOfPage); ok { +func (m *ChangeSingleBlocksList) GetChildren() *ChangeBlockChildren { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfChildren); ok { + return x.Children + } + return nil +} + +func (m *ChangeSingleBlocksList) GetPage() *ChangeBlockContentPage { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfPage); ok { return x.Page } return nil } -func (m *BlocksListSingleChange) GetDashboard() *ChangeBlockContentDashboard { - if x, ok := m.GetChange().(*BlocksListSingleChangeChangeOfDashboard); ok { +func (m *ChangeSingleBlocksList) GetDashboard() *ChangeBlockContentDashboard { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfDashboard); ok { return x.Dashboard } return nil } -func (m *BlocksListSingleChange) GetMedia() *ChangeBlockContentMedia { - if x, ok := m.GetChange().(*BlocksListSingleChangeChangeOfMedia); ok { - return x.Media +func (m *ChangeSingleBlocksList) GetVideo() *ChangeBlockContentVideo { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfVideo); ok { + return x.Video + } + return nil +} + +func (m *ChangeSingleBlocksList) GetImage() *ChangeBlockContentImage { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfImage); ok { + return x.Image + } + return nil +} + +func (m *ChangeSingleBlocksList) GetFile() *ChangeBlockContentFile { + if x, ok := m.GetChange().(*ChangeSingleBlocksListChangeOfFile); ok { + return x.File } return nil } // XXX_OneofWrappers is for the internal use of the proto package. -func (*BlocksListSingleChange) XXX_OneofWrappers() []interface{} { +func (*ChangeSingleBlocksList) XXX_OneofWrappers() []interface{} { return []interface{}{ - (*BlocksListSingleChangeChangeOfText)(nil), - (*BlocksListSingleChangeChangeOfBlockHeader)(nil), - (*BlocksListSingleChangeChangeOfBlockChildren)(nil), - (*BlocksListSingleChangeChangeOfPage)(nil), - (*BlocksListSingleChangeChangeOfDashboard)(nil), - (*BlocksListSingleChangeChangeOfMedia)(nil), + (*ChangeSingleBlocksListChangeOfText)(nil), + (*ChangeSingleBlocksListChangeOfFields)(nil), + (*ChangeSingleBlocksListChangeOfPremissions)(nil), + (*ChangeSingleBlocksListChangeOfChildren)(nil), + (*ChangeSingleBlocksListChangeOfPage)(nil), + (*ChangeSingleBlocksListChangeOfDashboard)(nil), + (*ChangeSingleBlocksListChangeOfVideo)(nil), + (*ChangeSingleBlocksListChangeOfImage)(nil), + (*ChangeSingleBlocksListChangeOfFile)(nil), } } -type BlockChanges struct { - Changes []*BlocksListSingleChange `protobuf:"bytes,1,rep,name=changes,proto3" json:"changes,omitempty"` +type ChangeMultiple struct { } -func (m *BlockChanges) Reset() { *m = BlockChanges{} } -func (m *BlockChanges) String() string { return proto.CompactTextString(m) } -func (*BlockChanges) ProtoMessage() {} -func (*BlockChanges) Descriptor() ([]byte, []int) { - return fileDescriptor_b16a38c6509bd894, []int{2} +func (m *ChangeMultiple) Reset() { *m = ChangeMultiple{} } +func (m *ChangeMultiple) String() string { return proto.CompactTextString(m) } +func (*ChangeMultiple) ProtoMessage() {} +func (*ChangeMultiple) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 2} } -func (m *BlockChanges) XXX_Unmarshal(b []byte) error { +func (m *ChangeMultiple) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *BlockChanges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ChangeMultiple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_BlockChanges.Marshal(b, m, deterministic) + return xxx_messageInfo_ChangeMultiple.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -873,19 +1120,56 @@ func (m *BlockChanges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } -func (m *BlockChanges) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlockChanges.Merge(m, src) +func (m *ChangeMultiple) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeMultiple.Merge(m, src) } -func (m *BlockChanges) XXX_Size() int { +func (m *ChangeMultiple) XXX_Size() int { return m.Size() } -func (m *BlockChanges) XXX_DiscardUnknown() { - xxx_messageInfo_BlockChanges.DiscardUnknown(m) +func (m *ChangeMultiple) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeMultiple.DiscardUnknown(m) } -var xxx_messageInfo_BlockChanges proto.InternalMessageInfo +var xxx_messageInfo_ChangeMultiple proto.InternalMessageInfo -func (m *BlockChanges) GetChanges() []*BlocksListSingleChange { +type ChangeMultipleBlocksList struct { + Changes []*ChangeSingleBlocksList `protobuf:"bytes,1,rep,name=changes,proto3" json:"changes,omitempty"` +} + +func (m *ChangeMultipleBlocksList) Reset() { *m = ChangeMultipleBlocksList{} } +func (m *ChangeMultipleBlocksList) String() string { return proto.CompactTextString(m) } +func (*ChangeMultipleBlocksList) ProtoMessage() {} +func (*ChangeMultipleBlocksList) Descriptor() ([]byte, []int) { + return fileDescriptor_b16a38c6509bd894, []int{0, 2, 0} +} +func (m *ChangeMultipleBlocksList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangeMultipleBlocksList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangeMultipleBlocksList.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ChangeMultipleBlocksList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangeMultipleBlocksList.Merge(m, src) +} +func (m *ChangeMultipleBlocksList) XXX_Size() int { + return m.Size() +} +func (m *ChangeMultipleBlocksList) XXX_DiscardUnknown() { + xxx_messageInfo_ChangeMultipleBlocksList.DiscardUnknown(m) +} + +var xxx_messageInfo_ChangeMultipleBlocksList proto.InternalMessageInfo + +func (m *ChangeMultipleBlocksList) GetChanges() []*ChangeSingleBlocksList { if m != nil { return m.Changes } @@ -895,64 +1179,74 @@ func (m *BlockChanges) GetChanges() []*BlocksListSingleChange { func init() { proto.RegisterType((*Change)(nil), "anytype.Change") proto.RegisterType((*ChangeBlock)(nil), "anytype.Change.Block") - proto.RegisterType((*ChangeBlockHeader)(nil), "anytype.Change.Block.Header") + proto.RegisterType((*ChangeBlockFields)(nil), "anytype.Change.Block.Fields") + proto.RegisterType((*ChangeBlockPermissions)(nil), "anytype.Change.Block.Permissions") proto.RegisterType((*ChangeBlockChildren)(nil), "anytype.Change.Block.Children") proto.RegisterType((*ChangeBlockContent)(nil), "anytype.Change.Block.Content") proto.RegisterType((*ChangeBlockContentPage)(nil), "anytype.Change.Block.Content.Page") proto.RegisterType((*ChangeBlockContentDashboard)(nil), "anytype.Change.Block.Content.Dashboard") - proto.RegisterType((*ChangeBlockContentMedia)(nil), "anytype.Change.Block.Content.Media") + proto.RegisterType((*ChangeBlockContentFile)(nil), "anytype.Change.Block.Content.File") + proto.RegisterType((*ChangeBlockContentImage)(nil), "anytype.Change.Block.Content.Image") + proto.RegisterType((*ChangeBlockContentVideo)(nil), "anytype.Change.Block.Content.Video") proto.RegisterType((*ChangeBlockContentText)(nil), "anytype.Change.Block.Content.Text") - proto.RegisterType((*BlocksListSingleChange)(nil), "anytype.BlocksListSingleChange") - proto.RegisterType((*BlockChanges)(nil), "anytype.BlockChanges") + proto.RegisterType((*ChangeSingle)(nil), "anytype.Change.Single") + proto.RegisterType((*ChangeSingleBlocksList)(nil), "anytype.Change.Single.BlocksList") + proto.RegisterType((*ChangeMultiple)(nil), "anytype.Change.Multiple") + proto.RegisterType((*ChangeMultipleBlocksList)(nil), "anytype.Change.Multiple.BlocksList") } func init() { proto.RegisterFile("changes.proto", fileDescriptor_b16a38c6509bd894) } var fileDescriptor_b16a38c6509bd894 = []byte{ - // 682 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0x3d, 0x6f, 0xd3, 0x50, - 0x14, 0xb5, 0xd3, 0x38, 0x1f, 0xd7, 0x6d, 0x85, 0x9e, 0x2a, 0x64, 0x99, 0xca, 0x44, 0x45, 0x82, - 0x0c, 0x95, 0x87, 0x20, 0x10, 0x88, 0xa1, 0x55, 0x5a, 0x81, 0x11, 0x14, 0x55, 0x6e, 0x27, 0xb6, - 0x97, 0xf8, 0x29, 0xb1, 0xe2, 0xd8, 0x91, 0xfd, 0x86, 0x66, 0xe2, 0x2f, 0x20, 0x7e, 0x0c, 0xbf, - 0x81, 0xb1, 0x0b, 0x88, 0x11, 0x35, 0x33, 0x3b, 0x23, 0xba, 0xd7, 0x2f, 0xb6, 0x5b, 0xa5, 0x69, - 0x37, 0xdf, 0x97, 0x73, 0xce, 0x3d, 0xef, 0x7e, 0xbc, 0xc0, 0xd6, 0x70, 0xcc, 0xe3, 0x91, 0xc8, - 0xdc, 0x59, 0x9a, 0xc8, 0x84, 0x35, 0x79, 0x3c, 0x97, 0xf3, 0x99, 0xb0, 0x37, 0xa7, 0x49, 0x20, - 0x22, 0x75, 0xbc, 0xf7, 0xaf, 0x09, 0x8d, 0x23, 0x02, 0xda, 0x7f, 0x9b, 0x60, 0xf4, 0xa3, 0x64, - 0x38, 0xb1, 0x7f, 0xea, 0xd0, 0xf0, 0x04, 0x0f, 0x44, 0xca, 0x1e, 0x40, 0x2d, 0x0c, 0x2c, 0xbd, - 0xa3, 0x77, 0xdb, 0x9e, 0xe6, 0xd7, 0xc2, 0x80, 0xbd, 0x84, 0x3a, 0xea, 0x58, 0xb5, 0x8e, 0xde, - 0xdd, 0xee, 0x75, 0x5c, 0xa5, 0xeb, 0x9e, 0xa0, 0xac, 0x4b, 0x02, 0x6e, 0x4e, 0x76, 0xcf, 0xe7, - 0x33, 0xe1, 0x69, 0x3e, 0xe1, 0xd9, 0x0e, 0xd4, 0x63, 0x3e, 0x15, 0xd6, 0x86, 0xd2, 0xa2, 0x08, - 0x4f, 0xc3, 0x61, 0x12, 0x5b, 0xf5, 0xe5, 0x29, 0x46, 0xec, 0x03, 0x98, 0x33, 0x91, 0x4e, 0xc3, - 0x2c, 0x0b, 0x93, 0x38, 0xb3, 0x8c, 0x8e, 0xde, 0x35, 0x7b, 0xcf, 0xd6, 0xa5, 0x3a, 0x2d, 0xe1, - 0x9e, 0xe6, 0x57, 0xd9, 0xfd, 0x16, 0x34, 0xf2, 0x52, 0xd8, 0x4f, 0xa1, 0x75, 0x34, 0x0e, 0xa3, - 0x20, 0x15, 0x31, 0xb3, 0xa1, 0x35, 0x54, 0xdf, 0x96, 0xde, 0xd9, 0xe8, 0xb6, 0xfd, 0x22, 0xb6, - 0x17, 0x06, 0x34, 0x8f, 0x92, 0x58, 0x8a, 0x58, 0xda, 0x5f, 0xa0, 0x7e, 0xca, 0x47, 0x82, 0x1d, - 0x80, 0x91, 0xc9, 0x79, 0x24, 0xa8, 0x16, 0xdb, 0xb7, 0x98, 0x51, 0x24, 0x17, 0x19, 0xee, 0x19, - 0xc2, 0x3d, 0xcd, 0xcf, 0x79, 0x6c, 0x1f, 0x8c, 0x01, 0x82, 0xa8, 0x70, 0x66, 0x6f, 0x67, 0x95, - 0x00, 0xa2, 0x09, 0x54, 0x31, 0xfd, 0x4d, 0x87, 0xf6, 0x31, 0xcf, 0xc6, 0x83, 0x84, 0xa7, 0x01, - 0x3b, 0xbe, 0x6e, 0x63, 0x7f, 0xad, 0x8d, 0x82, 0x76, 0xd3, 0xcb, 0x0b, 0x68, 0x8c, 0xa9, 0x6e, - 0xca, 0xcc, 0xa3, 0x35, 0xa5, 0xf5, 0x34, 0x5f, 0x81, 0x2b, 0xa6, 0x42, 0x30, 0x4e, 0x44, 0x10, - 0x72, 0xec, 0x5f, 0x14, 0xc6, 0x93, 0x62, 0x42, 0x28, 0x62, 0x87, 0xe8, 0x92, 0xcb, 0xe5, 0x90, - 0x74, 0xd7, 0xba, 0x24, 0x21, 0xf7, 0x0c, 0xf1, 0xb9, 0x43, 0x2e, 0x45, 0x25, 0xd5, 0xaf, 0x1a, - 0xd4, 0xcf, 0xc5, 0x85, 0xc4, 0x54, 0x52, 0x5c, 0xc8, 0x32, 0x15, 0x46, 0x65, 0x5f, 0x6a, 0xf7, - 0xe8, 0x0b, 0xea, 0xdc, 0xac, 0xc5, 0x01, 0x18, 0x53, 0x9e, 0x4e, 0x32, 0x1a, 0x4c, 0xf3, 0x3e, - 0x02, 0x27, 0x08, 0x47, 0x01, 0xe2, 0xb1, 0x0e, 0x80, 0x4c, 0x46, 0xa3, 0x48, 0xf0, 0x41, 0x24, - 0x68, 0x90, 0x5b, 0x9e, 0xe6, 0x57, 0xce, 0xd8, 0x27, 0x00, 0x84, 0x8a, 0x14, 0x17, 0x82, 0xa6, - 0xf9, 0xae, 0xce, 0x15, 0x79, 0x72, 0x0e, 0xea, 0x95, 0x0a, 0xcc, 0x81, 0xf6, 0x70, 0x2c, 0x86, - 0x13, 0x4a, 0xd8, 0x50, 0x09, 0xcb, 0x23, 0x66, 0x43, 0x93, 0x02, 0x11, 0x58, 0x4d, 0xf5, 0xeb, - 0xf2, 0xa0, 0x2c, 0xec, 0xde, 0xf7, 0x0d, 0x78, 0x48, 0x59, 0xb3, 0x8f, 0x61, 0x26, 0xcf, 0xc2, - 0x78, 0x14, 0x89, 0xfc, 0x29, 0x60, 0xdb, 0x6a, 0xeb, 0x71, 0x2d, 0x70, 0xe7, 0x5f, 0xa9, 0xd2, - 0xe7, 0xd3, 0xb2, 0x57, 0x58, 0xcf, 0xe1, 0x2b, 0xbc, 0x17, 0xed, 0x39, 0x04, 0x93, 0x06, 0x3a, - 0x9f, 0x25, 0x55, 0xe3, 0xdd, 0xd5, 0x02, 0xc5, 0xbc, 0x55, 0x29, 0xec, 0x2d, 0x6c, 0x51, 0xb8, - 0xdc, 0x5c, 0xaa, 0xb0, 0xd9, 0x73, 0x6e, 0x31, 0xa1, 0x50, 0x9e, 0xe6, 0x5f, 0xa7, 0xe1, 0x1d, - 0x66, 0x7c, 0x24, 0xd4, 0x63, 0x72, 0xc7, 0x1d, 0x70, 0x81, 0xf1, 0x0e, 0xc8, 0x60, 0xef, 0xa0, - 0x1d, 0x2c, 0x37, 0x89, 0xca, 0x5d, 0x9d, 0x92, 0x95, 0xf4, 0x62, 0xf1, 0xb0, 0x2f, 0x05, 0x97, - 0xbd, 0x01, 0x63, 0x8a, 0xc3, 0x4e, 0x5d, 0x31, 0x7b, 0x4f, 0xd6, 0x8b, 0xd0, 0x5e, 0xd0, 0x98, - 0xe1, 0x47, 0xa5, 0x71, 0xef, 0x61, 0xb3, 0x9f, 0x5f, 0x8d, 0x1e, 0x78, 0xf6, 0x1a, 0xdb, 0x4d, - 0x9f, 0xd4, 0x32, 0xb3, 0xf7, 0xb8, 0x10, 0x5e, 0xdd, 0x5f, 0x7f, 0x89, 0xef, 0xef, 0xfe, 0xb8, - 0x72, 0xf4, 0xcb, 0x2b, 0x47, 0xff, 0x73, 0xe5, 0xe8, 0x5f, 0x17, 0x8e, 0x76, 0xb9, 0x70, 0xb4, - 0xdf, 0x0b, 0x47, 0xfb, 0x5c, 0x9b, 0x0d, 0x06, 0x0d, 0xfa, 0x8f, 0x78, 0xfe, 0x3f, 0x00, 0x00, - 0xff, 0xff, 0x47, 0xbe, 0x47, 0xc0, 0x4b, 0x06, 0x00, 0x00, + // 754 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x5d, 0x6b, 0xd3, 0x50, + 0x18, 0x4e, 0xba, 0xa4, 0x1f, 0x6f, 0x75, 0xc8, 0x61, 0x42, 0x08, 0x23, 0xd4, 0x09, 0x5a, 0x65, + 0xe6, 0x62, 0x82, 0x0a, 0x13, 0x26, 0xdd, 0x87, 0x1d, 0x38, 0x99, 0xe9, 0xf4, 0xc2, 0xbb, 0xb4, + 0x39, 0x6b, 0x0f, 0x4b, 0x9b, 0x90, 0x9c, 0xcd, 0xf5, 0xca, 0x6b, 0xef, 0xbc, 0x16, 0x7f, 0x86, + 0xe0, 0x5f, 0xf0, 0x72, 0x17, 0x22, 0xbb, 0x53, 0xb6, 0x3f, 0x22, 0xef, 0x39, 0x69, 0x9a, 0x95, + 0xd8, 0x16, 0xdc, 0x5d, 0xcf, 0xe9, 0xfb, 0x3c, 0xef, 0xf3, 0x7e, 0x9c, 0x87, 0xc0, 0xcd, 0x4e, + 0xcf, 0x1d, 0x74, 0x69, 0x6c, 0x87, 0x51, 0xc0, 0x03, 0x52, 0x72, 0x07, 0x43, 0x3e, 0x0c, 0xa9, + 0x79, 0xa3, 0x1f, 0x78, 0xd4, 0x4f, 0xae, 0x57, 0xbe, 0xde, 0x82, 0xe2, 0xa6, 0x08, 0x34, 0xcf, + 0x01, 0xf4, 0x86, 0x1f, 0x74, 0x8e, 0xcc, 0xa7, 0x50, 0xdc, 0x61, 0xd4, 0xf7, 0x62, 0xf2, 0x08, + 0x8a, 0x87, 0xe2, 0x97, 0xa1, 0xd6, 0xd4, 0x7a, 0x75, 0xed, 0xb6, 0x9d, 0xd0, 0xd8, 0x7b, 0xc8, + 0x62, 0xb7, 0x78, 0x74, 0xdc, 0xe1, 0x4e, 0x12, 0x64, 0xbe, 0x81, 0xea, 0x3e, 0x8d, 0xfa, 0x2c, + 0x8e, 0x59, 0x30, 0x88, 0x49, 0x03, 0xaa, 0xe1, 0xf8, 0x98, 0x50, 0xd4, 0x26, 0x28, 0x44, 0x4a, + 0x3b, 0x03, 0x73, 0xb2, 0x20, 0xf3, 0x1e, 0x94, 0x37, 0x7b, 0xcc, 0xf7, 0x22, 0x3a, 0x20, 0x26, + 0x94, 0x3b, 0xc9, 0x6f, 0x43, 0xad, 0x2d, 0xd4, 0x2b, 0x4e, 0x7a, 0x36, 0xbf, 0x54, 0xa0, 0xb4, + 0x19, 0x0c, 0x38, 0x1d, 0x70, 0xf3, 0x23, 0x68, 0xfb, 0x6e, 0x97, 0x92, 0x0d, 0xd0, 0x63, 0x3e, + 0xf4, 0xa9, 0xc8, 0xbc, 0xb8, 0x76, 0x3f, 0x37, 0x73, 0x02, 0xb2, 0x11, 0x61, 0xb7, 0x30, 0xbc, + 0xa9, 0x38, 0x12, 0x47, 0x56, 0x41, 0x6f, 0x63, 0x90, 0x51, 0x10, 0xd2, 0x97, 0xf2, 0x08, 0x30, + 0x5a, 0x04, 0x35, 0xca, 0x50, 0x94, 0x3d, 0x37, 0x3f, 0xa9, 0x50, 0xd9, 0x72, 0xe3, 0x5e, 0x3b, + 0x70, 0x23, 0x8f, 0x6c, 0x5d, 0x95, 0xb1, 0x3a, 0x55, 0x46, 0x0a, 0xbb, 0x2e, 0x2d, 0xdf, 0x54, + 0xd0, 0x76, 0x98, 0x4f, 0x89, 0x09, 0xa5, 0x8e, 0x4c, 0x22, 0x84, 0x54, 0x9a, 0x8a, 0x33, 0xba, + 0x90, 0x9d, 0x72, 0x39, 0x15, 0xe4, 0xb3, 0x3a, 0x85, 0x6c, 0x76, 0x0b, 0xc3, 0xa5, 0x3a, 0x97, + 0x53, 0xb2, 0x0d, 0xa5, 0x30, 0xa2, 0x27, 0x8c, 0x7e, 0x30, 0x16, 0x84, 0xbe, 0x07, 0xb3, 0x29, + 0xf6, 0x25, 0x00, 0x75, 0x24, 0xd8, 0x8c, 0xec, 0xef, 0x2a, 0xe8, 0xbb, 0x7d, 0x9c, 0xe2, 0x34, + 0xdd, 0x2f, 0xae, 0xea, 0xae, 0x4f, 0x4d, 0x2a, 0xe8, 0x26, 0x85, 0xef, 0x4c, 0x0a, 0x7f, 0x38, + 0x07, 0xc7, 0x4c, 0xe5, 0xef, 0x98, 0x47, 0x83, 0xeb, 0x53, 0x2e, 0xe8, 0xfe, 0x53, 0xb9, 0xe4, + 0x98, 0xaa, 0xfc, 0x57, 0x01, 0xb4, 0x03, 0x7a, 0xca, 0xc9, 0x12, 0x68, 0x9c, 0x9e, 0x8e, 0x55, + 0x8b, 0xd3, 0xf8, 0x39, 0xcd, 0xb3, 0x24, 0xc8, 0x33, 0xb9, 0xc2, 0x1b, 0xa0, 0xf7, 0xdd, 0xe8, + 0x28, 0x4e, 0xf4, 0xce, 0x41, 0xb0, 0x87, 0xe1, 0x48, 0x20, 0x70, 0xa4, 0x06, 0xc0, 0x83, 0x6e, + 0xd7, 0xa7, 0x6e, 0xdb, 0xa7, 0x86, 0x56, 0x53, 0xeb, 0xe5, 0xa6, 0xe2, 0x64, 0xee, 0xc8, 0x6b, + 0x00, 0x0c, 0xa5, 0xd1, 0xc1, 0x30, 0xa4, 0x86, 0x3e, 0xc7, 0x83, 0x4b, 0xf3, 0x48, 0x0c, 0xf2, + 0x8d, 0x19, 0x88, 0x05, 0x95, 0x4e, 0x8f, 0x76, 0x8e, 0x44, 0xc2, 0x62, 0x92, 0x70, 0x7c, 0x25, + 0x46, 0x8c, 0x07, 0xea, 0x19, 0xa5, 0xe4, 0xdf, 0xd1, 0x45, 0xa6, 0xb1, 0xbf, 0x35, 0x28, 0xb6, + 0xd8, 0xa0, 0xeb, 0x53, 0xf3, 0xa7, 0x06, 0x20, 0x04, 0xc4, 0xaf, 0x58, 0xcc, 0xc9, 0x22, 0x14, + 0x98, 0x97, 0x98, 0x59, 0x81, 0x79, 0xe4, 0x59, 0xd2, 0x79, 0xf9, 0xc8, 0x57, 0x52, 0xe5, 0xd2, + 0xa3, 0x73, 0xa4, 0xa7, 0xd3, 0x79, 0x92, 0x5a, 0xb5, 0xec, 0xee, 0x72, 0x3e, 0x56, 0x1a, 0x7b, + 0x53, 0x19, 0x79, 0x36, 0xd9, 0x86, 0x6a, 0x18, 0xd1, 0xd4, 0xa4, 0x35, 0x01, 0xbe, 0x93, 0x0f, + 0xce, 0xb8, 0x74, 0x53, 0x71, 0xb2, 0x38, 0xf2, 0x3c, 0xe3, 0xcd, 0xba, 0xe0, 0xb0, 0xfe, 0x21, + 0x3e, 0x89, 0x6a, 0x2a, 0x63, 0xf7, 0xc6, 0xb2, 0x43, 0xb7, 0x2b, 0x3b, 0x3c, 0xb3, 0x6c, 0x74, + 0x6a, 0x2c, 0x1b, 0x11, 0xe4, 0x25, 0x54, 0xbc, 0x91, 0x65, 0x8a, 0x11, 0x64, 0xf7, 0x2a, 0x17, + 0x9e, 0x3a, 0x2c, 0x4e, 0x32, 0xc5, 0x92, 0x75, 0xd0, 0x4f, 0xf0, 0x89, 0x18, 0x65, 0x41, 0x72, + 0x77, 0x3a, 0x89, 0x78, 0x4d, 0xb8, 0x98, 0x02, 0x83, 0x60, 0x86, 0xce, 0x60, 0x54, 0xe6, 0x01, + 0x0b, 0x13, 0x41, 0xb0, 0xc0, 0x60, 0xf1, 0x87, 0xcc, 0xa7, 0x06, 0xcc, 0x53, 0x3c, 0x3a, 0x27, + 0x16, 0x8f, 0x88, 0xcc, 0x86, 0xbd, 0x85, 0xf2, 0xde, 0xb1, 0xcf, 0x59, 0xe8, 0x53, 0x73, 0xf7, + 0xca, 0x86, 0xad, 0xe3, 0x86, 0x8a, 0x2f, 0x01, 0xb1, 0x66, 0x39, 0xb3, 0x95, 0x9b, 0x69, 0x8f, + 0x31, 0xce, 0x08, 0xd1, 0x58, 0xfe, 0x71, 0x61, 0xa9, 0x67, 0x17, 0x96, 0xfa, 0xe7, 0xc2, 0x52, + 0x3f, 0x5f, 0x5a, 0xca, 0xd9, 0xa5, 0xa5, 0x9c, 0x5f, 0x5a, 0xca, 0xfb, 0x42, 0xd8, 0x6e, 0x17, + 0xc5, 0x37, 0xc4, 0xe3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x30, 0x65, 0x07, 0x05, 0x6b, 0x08, + 0x00, 0x00, } func (m *Change) Marshal() (dAtA []byte, err error) { @@ -1001,7 +1295,7 @@ func (m *ChangeBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ChangeBlockHeader) Marshal() (dAtA []byte, err error) { +func (m *ChangeBlockFields) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1011,89 +1305,51 @@ func (m *ChangeBlockHeader) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ChangeBlockHeader) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeBlockFields) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangeBlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeBlockFields) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Change != nil { + if m.Fields != nil { { - size := m.Change.Size() - i -= size - if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil { + size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } + i -= size + i = encodeVarintChanges(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ChangeBlockHeaderChangeOfId) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeBlockPermissions) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ChangeBlockPermissions) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangeBlockHeaderChangeOfId) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i -= len(m.Id) - copy(dAtA[i:], m.Id) - i = encodeVarintChanges(dAtA, i, uint64(len(m.Id))) - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} -func (m *ChangeBlockHeaderChangeOfType) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ChangeBlockHeaderChangeOfType) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i = encodeVarintChanges(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x10 - return len(dAtA) - i, nil -} -func (m *ChangeBlockHeaderChangeOfName) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ChangeBlockHeaderChangeOfName) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintChanges(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0x1a - return len(dAtA) - i, nil -} -func (m *ChangeBlockHeaderChangeOfIcon) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ChangeBlockHeaderChangeOfIcon) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i -= len(m.Icon) - copy(dAtA[i:], m.Icon) - i = encodeVarintChanges(dAtA, i, uint64(len(m.Icon))) - i-- - dAtA[i] = 0x22 - return len(dAtA) - i, nil -} -func (m *ChangeBlockHeaderChangeOfPermissions) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ChangeBlockHeaderChangeOfPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeBlockPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) + _ = i + var l int + _ = l if m.Permissions != nil { { size, err := m.Permissions.MarshalToSizedBuffer(dAtA[:i]) @@ -1104,10 +1360,11 @@ func (m *ChangeBlockHeaderChangeOfPermissions) MarshalToSizedBuffer(dAtA []byte) i = encodeVarintChanges(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a + dAtA[i] = 0xa } return len(dAtA) - i, nil } + func (m *ChangeBlockChildren) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1272,16 +1529,16 @@ func (m *ChangeBlockContentDashboardChangeOfStyle) MarshalToSizedBuffer(dAtA []b dAtA[i] = 0x8 return len(dAtA) - i, nil } -func (m *ChangeBlockContentDashboardChangeOfHeader) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeBlockContentDashboardChangeOfBlock) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangeBlockContentDashboardChangeOfHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeBlockContentDashboardChangeOfBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Header != nil { + if m.Block != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1293,7 +1550,7 @@ func (m *ChangeBlockContentDashboardChangeOfHeader) MarshalToSizedBuffer(dAtA [] } return len(dAtA) - i, nil } -func (m *ChangeBlockContentMedia) Marshal() (dAtA []byte, err error) { +func (m *ChangeBlockContentFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1303,12 +1560,12 @@ func (m *ChangeBlockContentMedia) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ChangeBlockContentMedia) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeBlockContentFile) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangeBlockContentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeBlockContentFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -1325,32 +1582,211 @@ func (m *ChangeBlockContentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *ChangeBlockContentMediaChangeOfLink) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeBlockContentFileChangeOfContent) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangeBlockContentMediaChangeOfLink) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeBlockContentFileChangeOfContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - i -= len(m.Link) - copy(dAtA[i:], m.Link) - i = encodeVarintChanges(dAtA, i, uint64(len(m.Link))) + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintChanges(dAtA, i, uint64(len(m.Content))) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *ChangeBlockContentMediaChangeOfState) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeBlockContentFileChangeOfState) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangeBlockContentMediaChangeOfState) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeBlockContentFileChangeOfState) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) i = encodeVarintChanges(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x10 return len(dAtA) - i, nil } +func (m *ChangeBlockContentFileChangeOfPreview) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentFileChangeOfPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Preview != nil { + { + size, err := m.Preview.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChanges(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *ChangeBlockContentImage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ChangeBlockContentImage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentImage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Change != nil { + { + size := m.Change.Size() + i -= size + if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ChangeBlockContentImageChangeOfContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentImageChangeOfContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintChanges(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} +func (m *ChangeBlockContentImageChangeOfState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentImageChangeOfState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i = encodeVarintChanges(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x10 + return len(dAtA) - i, nil +} +func (m *ChangeBlockContentImageChangeOfPreview) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentImageChangeOfPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Preview != nil { + { + size, err := m.Preview.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChanges(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *ChangeBlockContentVideo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ChangeBlockContentVideo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Change != nil { + { + size := m.Change.Size() + i -= size + if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *ChangeBlockContentVideoChangeOfContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentVideoChangeOfContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintChanges(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} +func (m *ChangeBlockContentVideoChangeOfState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentVideoChangeOfState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i = encodeVarintChanges(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x10 + return len(dAtA) - i, nil +} +func (m *ChangeBlockContentVideoChangeOfPreview) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeBlockContentVideoChangeOfPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Preview != nil { + { + size, err := m.Preview.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChanges(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} func (m *ChangeBlockContentText) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1493,7 +1929,7 @@ func (m *ChangeBlockContentTextChangeOfChecked) MarshalToSizedBuffer(dAtA []byte dAtA[i] = 0x38 return len(dAtA) - i, nil } -func (m *BlocksListSingleChange) Marshal() (dAtA []byte, err error) { +func (m *ChangeSingle) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1503,12 +1939,35 @@ func (m *BlocksListSingleChange) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BlocksListSingleChange) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingle) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingle) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ChangeSingleBlocksList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ChangeSingleBlocksList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeSingleBlocksList) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -1534,12 +1993,12 @@ func (m *BlocksListSingleChange) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *BlocksListSingleChangeChangeOfText) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfText) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChangeChangeOfText) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfText) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.Text != nil { { @@ -1555,16 +2014,16 @@ func (m *BlocksListSingleChangeChangeOfText) MarshalToSizedBuffer(dAtA []byte) ( } return len(dAtA) - i, nil } -func (m *BlocksListSingleChangeChangeOfBlockHeader) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfFields) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChangeChangeOfBlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfFields) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.BlockHeader != nil { + if m.Fields != nil { { - size, err := m.BlockHeader.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1576,16 +2035,16 @@ func (m *BlocksListSingleChangeChangeOfBlockHeader) MarshalToSizedBuffer(dAtA [] } return len(dAtA) - i, nil } -func (m *BlocksListSingleChangeChangeOfBlockChildren) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfPremissions) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChangeChangeOfBlockChildren) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfPremissions) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.BlockChildren != nil { + if m.Premissions != nil { { - size, err := m.BlockChildren.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Premissions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1597,16 +2056,16 @@ func (m *BlocksListSingleChangeChangeOfBlockChildren) MarshalToSizedBuffer(dAtA } return len(dAtA) - i, nil } -func (m *BlocksListSingleChangeChangeOfPage) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfChildren) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChangeChangeOfPage) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfChildren) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Page != nil { + if m.Children != nil { { - size, err := m.Page.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Children.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1618,16 +2077,16 @@ func (m *BlocksListSingleChangeChangeOfPage) MarshalToSizedBuffer(dAtA []byte) ( } return len(dAtA) - i, nil } -func (m *BlocksListSingleChangeChangeOfDashboard) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfPage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChangeChangeOfDashboard) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfPage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Dashboard != nil { + if m.Page != nil { { - size, err := m.Dashboard.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Page.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1639,16 +2098,16 @@ func (m *BlocksListSingleChangeChangeOfDashboard) MarshalToSizedBuffer(dAtA []by } return len(dAtA) - i, nil } -func (m *BlocksListSingleChangeChangeOfMedia) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfDashboard) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlocksListSingleChangeChangeOfMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeSingleBlocksListChangeOfDashboard) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Media != nil { + if m.Dashboard != nil { { - size, err := m.Media.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Dashboard.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1660,7 +2119,70 @@ func (m *BlocksListSingleChangeChangeOfMedia) MarshalToSizedBuffer(dAtA []byte) } return len(dAtA) - i, nil } -func (m *BlockChanges) Marshal() (dAtA []byte, err error) { +func (m *ChangeSingleBlocksListChangeOfVideo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeSingleBlocksListChangeOfVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Video != nil { + { + size, err := m.Video.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChanges(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + return len(dAtA) - i, nil +} +func (m *ChangeSingleBlocksListChangeOfImage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeSingleBlocksListChangeOfImage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Image != nil { + { + size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintChanges(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + return len(dAtA) - i, nil +} +func (m *ChangeSingleBlocksListChangeOfFile) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeSingleBlocksListChangeOfFile) 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 = encodeVarintChanges(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + return len(dAtA) - i, nil +} +func (m *ChangeMultiple) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1670,12 +2192,35 @@ func (m *BlockChanges) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BlockChanges) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangeMultiple) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlockChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangeMultiple) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *ChangeMultipleBlocksList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ChangeMultipleBlocksList) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChangeMultipleBlocksList) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -1726,58 +2271,20 @@ func (m *ChangeBlock) Size() (n int) { return n } -func (m *ChangeBlockHeader) Size() (n int) { +func (m *ChangeBlockFields) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Change != nil { - n += m.Change.Size() + if m.Fields != nil { + l = m.Fields.Size() + n += 1 + l + sovChanges(uint64(l)) } return n } -func (m *ChangeBlockHeaderChangeOfId) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Id) - n += 1 + l + sovChanges(uint64(l)) - return n -} -func (m *ChangeBlockHeaderChangeOfType) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 1 + sovChanges(uint64(m.Type)) - return n -} -func (m *ChangeBlockHeaderChangeOfName) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Name) - n += 1 + l + sovChanges(uint64(l)) - return n -} -func (m *ChangeBlockHeaderChangeOfIcon) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Icon) - n += 1 + l + sovChanges(uint64(l)) - return n -} -func (m *ChangeBlockHeaderChangeOfPermissions) Size() (n int) { +func (m *ChangeBlockPermissions) Size() (n int) { if m == nil { return 0 } @@ -1789,6 +2296,7 @@ func (m *ChangeBlockHeaderChangeOfPermissions) Size() (n int) { } return n } + func (m *ChangeBlockChildren) Size() (n int) { if m == nil { return 0 @@ -1867,19 +2375,19 @@ func (m *ChangeBlockContentDashboardChangeOfStyle) Size() (n int) { n += 1 + sovChanges(uint64(m.Style)) return n } -func (m *ChangeBlockContentDashboardChangeOfHeader) Size() (n int) { +func (m *ChangeBlockContentDashboardChangeOfBlock) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() + if m.Block != nil { + l = m.Block.Size() n += 1 + l + sovChanges(uint64(l)) } return n } -func (m *ChangeBlockContentMedia) Size() (n int) { +func (m *ChangeBlockContentFile) Size() (n int) { if m == nil { return 0 } @@ -1891,17 +2399,17 @@ func (m *ChangeBlockContentMedia) Size() (n int) { return n } -func (m *ChangeBlockContentMediaChangeOfLink) Size() (n int) { +func (m *ChangeBlockContentFileChangeOfContent) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Link) + l = len(m.Content) n += 1 + l + sovChanges(uint64(l)) return n } -func (m *ChangeBlockContentMediaChangeOfState) Size() (n int) { +func (m *ChangeBlockContentFileChangeOfState) Size() (n int) { if m == nil { return 0 } @@ -1910,6 +2418,104 @@ func (m *ChangeBlockContentMediaChangeOfState) Size() (n int) { n += 1 + sovChanges(uint64(m.State)) return n } +func (m *ChangeBlockContentFileChangeOfPreview) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Preview != nil { + l = m.Preview.Size() + n += 1 + l + sovChanges(uint64(l)) + } + return n +} +func (m *ChangeBlockContentImage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Change != nil { + n += m.Change.Size() + } + return n +} + +func (m *ChangeBlockContentImageChangeOfContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Content) + n += 1 + l + sovChanges(uint64(l)) + return n +} +func (m *ChangeBlockContentImageChangeOfState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovChanges(uint64(m.State)) + return n +} +func (m *ChangeBlockContentImageChangeOfPreview) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Preview != nil { + l = m.Preview.Size() + n += 1 + l + sovChanges(uint64(l)) + } + return n +} +func (m *ChangeBlockContentVideo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Change != nil { + n += m.Change.Size() + } + return n +} + +func (m *ChangeBlockContentVideoChangeOfContent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Content) + n += 1 + l + sovChanges(uint64(l)) + return n +} +func (m *ChangeBlockContentVideoChangeOfState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + n += 1 + sovChanges(uint64(m.State)) + return n +} +func (m *ChangeBlockContentVideoChangeOfPreview) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Preview != nil { + l = m.Preview.Size() + n += 1 + l + sovChanges(uint64(l)) + } + return n +} func (m *ChangeBlockContentText) Size() (n int) { if m == nil { return 0 @@ -1989,7 +2595,16 @@ func (m *ChangeBlockContentTextChangeOfChecked) Size() (n int) { n += 2 return n } -func (m *BlocksListSingleChange) Size() (n int) { +func (m *ChangeSingle) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ChangeSingleBlocksList) Size() (n int) { if m == nil { return 0 } @@ -2007,7 +2622,7 @@ func (m *BlocksListSingleChange) Size() (n int) { return n } -func (m *BlocksListSingleChangeChangeOfText) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfText) Size() (n int) { if m == nil { return 0 } @@ -2019,31 +2634,43 @@ func (m *BlocksListSingleChangeChangeOfText) Size() (n int) { } return n } -func (m *BlocksListSingleChangeChangeOfBlockHeader) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfFields) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.BlockHeader != nil { - l = m.BlockHeader.Size() + if m.Fields != nil { + l = m.Fields.Size() n += 1 + l + sovChanges(uint64(l)) } return n } -func (m *BlocksListSingleChangeChangeOfBlockChildren) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfPremissions) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.BlockChildren != nil { - l = m.BlockChildren.Size() + if m.Premissions != nil { + l = m.Premissions.Size() n += 1 + l + sovChanges(uint64(l)) } return n } -func (m *BlocksListSingleChangeChangeOfPage) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfChildren) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Children != nil { + l = m.Children.Size() + n += 1 + l + sovChanges(uint64(l)) + } + return n +} +func (m *ChangeSingleBlocksListChangeOfPage) Size() (n int) { if m == nil { return 0 } @@ -2055,7 +2682,7 @@ func (m *BlocksListSingleChangeChangeOfPage) Size() (n int) { } return n } -func (m *BlocksListSingleChangeChangeOfDashboard) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfDashboard) Size() (n int) { if m == nil { return 0 } @@ -2067,19 +2694,52 @@ func (m *BlocksListSingleChangeChangeOfDashboard) Size() (n int) { } return n } -func (m *BlocksListSingleChangeChangeOfMedia) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfVideo) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Media != nil { - l = m.Media.Size() + if m.Video != nil { + l = m.Video.Size() n += 1 + l + sovChanges(uint64(l)) } return n } -func (m *BlockChanges) Size() (n int) { +func (m *ChangeSingleBlocksListChangeOfImage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Image != nil { + l = m.Image.Size() + n += 1 + l + sovChanges(uint64(l)) + } + return n +} +func (m *ChangeSingleBlocksListChangeOfFile) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.File != nil { + l = m.File.Size() + n += 1 + l + sovChanges(uint64(l)) + } + return n +} +func (m *ChangeMultiple) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *ChangeMultipleBlocksList) Size() (n int) { if m == nil { return 0 } @@ -2206,7 +2866,7 @@ func (m *ChangeBlock) Unmarshal(dAtA []byte) error { } return nil } -func (m *ChangeBlockHeader) Unmarshal(dAtA []byte) error { +func (m *ChangeBlockFields) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2229,17 +2889,17 @@ func (m *ChangeBlockHeader) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Header: wiretype end group for non-group") + return fmt.Errorf("proto: Fields: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowChanges @@ -2249,109 +2909,82 @@ func (m *ChangeBlockHeader) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthChanges } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthChanges } if postIndex > l { return io.ErrUnexpectedEOF } - m.Change = &ChangeBlockHeaderChangeOfId{string(dAtA[iNdEx:postIndex])} + if m.Fields == nil { + m.Fields = &ModelStruct{} + } + if err := m.Fields.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) + default: + iNdEx = preIndex + skippy, err := skipChanges(dAtA[iNdEx:]) + if err != nil { + return err } - var v ModelBlockHeaderType - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChanges - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= ModelBlockHeaderType(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.Change = &ChangeBlockHeaderChangeOfType{v} - 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 ErrIntOverflowChanges - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { + if skippy < 0 { return ErrInvalidLengthChanges } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthChanges } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Change = &ChangeBlockHeaderChangeOfName{string(dAtA[iNdEx:postIndex])} - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangeBlockPermissions) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowChanges - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthChanges - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthChanges - } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Change = &ChangeBlockHeaderChangeOfIcon{string(dAtA[iNdEx:postIndex])} - iNdEx = postIndex - case 5: + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Permissions: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Permissions: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType) } @@ -2380,11 +3013,12 @@ func (m *ChangeBlockHeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ModelBlockHeaderPermissions{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Permissions == nil { + m.Permissions = &ModelBlockPermissions{} + } + if err := m.Permissions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &ChangeBlockHeaderChangeOfPermissions{v} iNdEx = postIndex default: iNdEx = preIndex @@ -2707,7 +3341,7 @@ func (m *ChangeBlockContentDashboard) Unmarshal(dAtA []byte) error { m.Change = &ChangeBlockContentDashboardChangeOfStyle{v} case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -2734,11 +3368,11 @@ func (m *ChangeBlockContentDashboard) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ModelBlockHeader{} + v := &ModelBlock{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &ChangeBlockContentDashboardChangeOfHeader{v} + m.Change = &ChangeBlockContentDashboardChangeOfBlock{v} iNdEx = postIndex default: iNdEx = preIndex @@ -2764,7 +3398,7 @@ func (m *ChangeBlockContentDashboard) Unmarshal(dAtA []byte) error { } return nil } -func (m *ChangeBlockContentMedia) Unmarshal(dAtA []byte) error { +func (m *ChangeBlockContentFile) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2787,15 +3421,15 @@ func (m *ChangeBlockContentMedia) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Media: wiretype end group for non-group") + return fmt.Errorf("proto: File: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Media: illegal tag %d (wire type %d)", fieldNum, wire) + 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 Link", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -2823,13 +3457,13 @@ func (m *ChangeBlockContentMedia) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Change = &ChangeBlockContentMediaChangeOfLink{string(dAtA[iNdEx:postIndex])} + m.Change = &ChangeBlockContentFileChangeOfContent{string(dAtA[iNdEx:postIndex])} iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } - var v ModelBlockContentMediaState + var v ModelBlockContentFileState for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowChanges @@ -2839,12 +3473,327 @@ func (m *ChangeBlockContentMedia) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= ModelBlockContentMediaState(b&0x7F) << shift + v |= ModelBlockContentFileState(b&0x7F) << shift if b < 0x80 { break } } - m.Change = &ChangeBlockContentMediaChangeOfState{v} + m.Change = &ChangeBlockContentFileChangeOfState{v} + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Preview", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ModelBlockContentFilePreview{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Change = &ChangeBlockContentFileChangeOfPreview{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipChanges(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangeBlockContentImage) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Image: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Change = &ChangeBlockContentImageChangeOfContent{string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var v ModelBlockContentImageState + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= ModelBlockContentImageState(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Change = &ChangeBlockContentImageChangeOfState{v} + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Preview", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ModelBlockContentImagePreview{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Change = &ChangeBlockContentImageChangeOfPreview{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipChanges(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangeBlockContentVideo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Video: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Video: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Change = &ChangeBlockContentVideoChangeOfContent{string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var v ModelBlockContentVideoState + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= ModelBlockContentVideoState(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Change = &ChangeBlockContentVideoChangeOfState{v} + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Preview", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ModelBlockContentVideoPreview{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Change = &ChangeBlockContentVideoChangeOfPreview{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipChanges(dAtA[iNdEx:]) @@ -3092,7 +4041,7 @@ func (m *ChangeBlockContentText) Unmarshal(dAtA []byte) error { } return nil } -func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { +func (m *ChangeSingle) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3115,10 +4064,63 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BlocksListSingleChange: wiretype end group for non-group") + return fmt.Errorf("proto: Single: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BlocksListSingleChange: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Single: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipChanges(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangeSingleBlocksList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlocksList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlocksList: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3186,11 +4188,11 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &BlocksListSingleChangeChangeOfText{v} + m.Change = &ChangeSingleBlocksListChangeOfText{v} iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3217,15 +4219,50 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ChangeBlockHeader{} + v := &ChangeBlockFields{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &BlocksListSingleChangeChangeOfBlockHeader{v} + m.Change = &ChangeSingleBlocksListChangeOfFields{v} iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockChildren", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Premissions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ChangeBlockPermissions{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Change = &ChangeSingleBlocksListChangeOfPremissions{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Children", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3256,9 +4293,9 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &BlocksListSingleChangeChangeOfBlockChildren{v} + m.Change = &ChangeSingleBlocksListChangeOfChildren{v} iNdEx = postIndex - case 5: + case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType) } @@ -3291,9 +4328,9 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &BlocksListSingleChangeChangeOfPage{v} + m.Change = &ChangeSingleBlocksListChangeOfPage{v} iNdEx = postIndex - case 6: + case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Dashboard", wireType) } @@ -3326,11 +4363,11 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &BlocksListSingleChangeChangeOfDashboard{v} + m.Change = &ChangeSingleBlocksListChangeOfDashboard{v} iNdEx = postIndex - case 7: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Media", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Video", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3357,11 +4394,81 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ChangeBlockContentMedia{} + v := &ChangeBlockContentVideo{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Change = &BlocksListSingleChangeChangeOfMedia{v} + m.Change = &ChangeSingleBlocksListChangeOfVideo{v} + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ChangeBlockContentImage{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Change = &ChangeSingleBlocksListChangeOfImage{v} + iNdEx = postIndex + case 10: + 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 ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthChanges + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthChanges + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ChangeBlockContentFile{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Change = &ChangeSingleBlocksListChangeOfFile{v} iNdEx = postIndex default: iNdEx = preIndex @@ -3387,7 +4494,7 @@ func (m *BlocksListSingleChange) Unmarshal(dAtA []byte) error { } return nil } -func (m *BlockChanges) Unmarshal(dAtA []byte) error { +func (m *ChangeMultiple) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3410,10 +4517,63 @@ func (m *BlockChanges) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BlockChanges: wiretype end group for non-group") + return fmt.Errorf("proto: Multiple: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BlockChanges: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Multiple: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipChanges(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthChanges + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChangeMultipleBlocksList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowChanges + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BlocksList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlocksList: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -3445,7 +4605,7 @@ func (m *BlockChanges) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Changes = append(m.Changes, &BlocksListSingleChange{}) + m.Changes = append(m.Changes, &ChangeSingleBlocksList{}) if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } diff --git a/pb/commands.pb.go b/pb/commands.pb.go index ae1d68a0c..c6a8b9255 100644 --- a/pb/commands.pb.go +++ b/pb/commands.pb.go @@ -916,8 +916,7 @@ func (m *RpcBlockOpenRequest) GetId() string { } type RpcBlockOpenResponse struct { - Error *RpcBlockOpenResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` - BlockHeader *ModelBlockHeader `protobuf:"bytes,2,opt,name=blockHeader,proto3" json:"blockHeader,omitempty"` + Error *RpcBlockOpenResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` } func (m *RpcBlockOpenResponse) Reset() { *m = RpcBlockOpenResponse{} } @@ -960,13 +959,6 @@ func (m *RpcBlockOpenResponse) GetError() *RpcBlockOpenResponseError { return nil } -func (m *RpcBlockOpenResponse) GetBlockHeader() *ModelBlockHeader { - if m != nil { - return m.BlockHeader - } - return nil -} - type RpcBlockOpenResponseError struct { Code RpcBlockOpenResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockOpenResponseErrorCode" json:"code,omitempty"` Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` @@ -1056,8 +1048,8 @@ func (m *RpcBlockCreate) XXX_DiscardUnknown() { var xxx_messageInfo_RpcBlockCreate proto.InternalMessageInfo type RpcBlockCreateRequest struct { - Type ModelBlockHeaderType `protobuf:"varint,1,opt,name=type,proto3,enum=anytype.ModelBlockHeaderType" json:"type,omitempty"` - ContextBlockId string `protobuf:"bytes,2,opt,name=contextBlockId,proto3" json:"contextBlockId,omitempty"` + Block *ModelBlock `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` + ContextBlockId string `protobuf:"bytes,2,opt,name=contextBlockId,proto3" json:"contextBlockId,omitempty"` } func (m *RpcBlockCreateRequest) Reset() { *m = RpcBlockCreateRequest{} } @@ -1093,11 +1085,11 @@ func (m *RpcBlockCreateRequest) XXX_DiscardUnknown() { var xxx_messageInfo_RpcBlockCreateRequest proto.InternalMessageInfo -func (m *RpcBlockCreateRequest) GetType() ModelBlockHeaderType { +func (m *RpcBlockCreateRequest) GetBlock() *ModelBlock { if m != nil { - return m.Type + return m.Block } - return ModelBlockHeader_DASHBOARD + return nil } func (m *RpcBlockCreateRequest) GetContextBlockId() string { @@ -1240,7 +1232,7 @@ func (m *RpcBlockUpdate) XXX_DiscardUnknown() { var xxx_messageInfo_RpcBlockUpdate proto.InternalMessageInfo type RpcBlockUpdateRequest struct { - Changes *BlockChanges `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"` + Changes *ChangeMultipleBlocksList `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"` } func (m *RpcBlockUpdateRequest) Reset() { *m = RpcBlockUpdateRequest{} } @@ -1276,7 +1268,7 @@ func (m *RpcBlockUpdateRequest) XXX_DiscardUnknown() { var xxx_messageInfo_RpcBlockUpdateRequest proto.InternalMessageInfo -func (m *RpcBlockUpdateRequest) GetChanges() *BlockChanges { +func (m *RpcBlockUpdateRequest) GetChanges() *ChangeMultipleBlocksList { if m != nil { return m.Changes } @@ -3682,103 +3674,102 @@ func init() { func init() { proto.RegisterFile("commands.proto", fileDescriptor_0dff099eb2e3dfdb) } var fileDescriptor_0dff099eb2e3dfdb = []byte{ - // 1521 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4f, 0x6c, 0xdb, 0x64, - 0x1b, 0x6f, 0x1c, 0xa7, 0x69, 0x9f, 0x76, 0xfd, 0x3c, 0x6b, 0x9b, 0xba, 0x77, 0x53, 0x57, 0x75, - 0xdf, 0xb7, 0xaf, 0xfb, 0xe7, 0x4d, 0x1d, 0x1c, 0x98, 0x18, 0x9b, 0x93, 0x38, 0xad, 0x21, 0xb1, - 0xab, 0x37, 0x4e, 0x0b, 0x5c, 0x2c, 0x37, 0x7e, 0x9b, 0x06, 0x92, 0x38, 0x38, 0x5e, 0x47, 0x77, - 0xe3, 0x80, 0x38, 0x70, 0x41, 0x48, 0x3b, 0x21, 0x21, 0xb8, 0x21, 0x36, 0x24, 0x0e, 0x48, 0x43, - 0x48, 0x80, 0x04, 0x1c, 0x00, 0x81, 0x34, 0x40, 0x42, 0x5c, 0x40, 0x6c, 0x3b, 0xa2, 0xdd, 0xe0, - 0xb0, 0x03, 0x08, 0xbd, 0xb6, 0x93, 0xd8, 0x55, 0x92, 0xd9, 0xd5, 0xa6, 0xed, 0xe6, 0xf7, 0xcd, - 0xf3, 0xfe, 0x9e, 0xe7, 0xf9, 0xfd, 0x9e, 0xe7, 0xfd, 0x13, 0x98, 0xaa, 0x58, 0x8d, 0x86, 0xd1, - 0x34, 0xdb, 0x42, 0xcb, 0xb6, 0x1c, 0x8b, 0x4f, 0x1b, 0xcd, 0x2d, 0x67, 0xab, 0x45, 0xd0, 0x64, - 0xc3, 0x32, 0x49, 0xdd, 0x9f, 0x46, 0xbb, 0x2a, 0x1b, 0x46, 0xb3, 0x4a, 0xfc, 0xe1, 0xdc, 0x95, - 0x13, 0x90, 0xc4, 0xad, 0x0a, 0xba, 0x0b, 0x90, 0xca, 0xd4, 0xad, 0xca, 0x8b, 0xe8, 0xd5, 0x24, - 0xa4, 0x97, 0x6a, 0x6d, 0xc7, 0xb2, 0xb7, 0xd0, 0x5d, 0x06, 0xd8, 0xa2, 0xb5, 0x49, 0x50, 0x05, - 0xd2, 0x98, 0xbc, 0x74, 0x91, 0xb4, 0x1d, 0x7e, 0x0a, 0x98, 0x9a, 0x39, 0x9d, 0x98, 0x4d, 0xcc, - 0x8f, 0x63, 0xa6, 0x66, 0xf2, 0x47, 0xa8, 0xe7, 0xa6, 0x43, 0x5e, 0x76, 0xdc, 0xf5, 0xb2, 0x39, - 0xcd, 0xb8, 0xbf, 0x6d, 0x9b, 0xe5, 0x67, 0x61, 0xa2, 0x61, 0x6d, 0x92, 0xbc, 0x65, 0x5f, 0x32, - 0x6c, 0x73, 0x3a, 0x39, 0x9b, 0x98, 0x1f, 0xc3, 0xc1, 0x29, 0xf4, 0x3a, 0x03, 0x63, 0x98, 0xb4, - 0x5b, 0x56, 0xb3, 0x4d, 0xf8, 0x1c, 0xa4, 0x88, 0x6d, 0x5b, 0xb6, 0xeb, 0x69, 0x62, 0x41, 0x10, - 0xfc, 0x74, 0x04, 0xdc, 0xaa, 0x08, 0x2e, 0xa6, 0xe0, 0x47, 0x29, 0xd0, 0x08, 0x85, 0xce, 0x42, - 0x41, 0xa2, 0xab, 0xb0, 0xb7, 0x18, 0x7d, 0x9c, 0x80, 0x94, 0x3b, 0xc1, 0x2f, 0x02, 0x5b, 0xb1, - 0x4c, 0xe2, 0xc2, 0x4d, 0x2d, 0x9c, 0x89, 0x07, 0x27, 0x64, 0x2d, 0x93, 0x60, 0x17, 0x80, 0xe6, - 0x61, 0x92, 0x76, 0xc5, 0xae, 0xb5, 0x9c, 0x9a, 0xd5, 0xf4, 0x93, 0x0d, 0x4e, 0xcd, 0xe5, 0x80, - 0xa5, 0xf6, 0xfc, 0x18, 0xb0, 0x4a, 0xb9, 0x50, 0xe0, 0x46, 0xf8, 0xdd, 0xb0, 0xab, 0xac, 0x3c, - 0xa3, 0xa8, 0xab, 0x8a, 0x2e, 0x61, 0xac, 0x62, 0x2e, 0xc1, 0xef, 0x82, 0xf1, 0x8c, 0x98, 0xd3, - 0x65, 0x65, 0xb9, 0xac, 0x71, 0x0c, 0xcf, 0xc1, 0x64, 0x56, 0x54, 0x74, 0x45, 0xd5, 0xf4, 0xa2, - 0xba, 0x22, 0x71, 0x49, 0xf4, 0x1d, 0x03, 0xac, 0xda, 0x22, 0x4d, 0xb4, 0x7f, 0x20, 0xf7, 0xe8, - 0xbd, 0x20, 0x63, 0x4f, 0x86, 0x19, 0x3b, 0xd2, 0x27, 0x45, 0x8a, 0xd7, 0x9f, 0x29, 0xfe, 0x1c, - 0x4c, 0xac, 0x51, 0x9b, 0x25, 0x62, 0x98, 0xc4, 0x76, 0xd3, 0x9a, 0x58, 0x38, 0xd0, 0xc5, 0x28, - 0xd2, 0x1a, 0xea, 0x10, 0xe5, 0x9a, 0xe0, 0xa0, 0x3d, 0x7a, 0xbb, 0x4b, 0xf4, 0xf9, 0x10, 0xd1, - 0xc7, 0xa3, 0x45, 0x11, 0x8f, 0xe0, 0x85, 0xf8, 0x04, 0xa3, 0x9b, 0x0c, 0x8c, 0x66, 0x6d, 0x62, - 0x38, 0x04, 0x55, 0x7b, 0x84, 0x3e, 0x06, 0x2c, 0x0d, 0xce, 0x0f, 0x76, 0x76, 0x48, 0xba, 0x82, - 0xb6, 0xd5, 0x22, 0xd8, 0xb5, 0x8e, 0x5a, 0xf2, 0xe8, 0x4e, 0x22, 0x20, 0xcf, 0x53, 0x61, 0x79, - 0xe6, 0xfb, 0x10, 0xe3, 0xc5, 0x37, 0xa0, 0x94, 0xdf, 0xe9, 0x32, 0x2c, 0x86, 0x18, 0x3e, 0x19, - 0x15, 0xe8, 0xc1, 0x73, 0xfc, 0x11, 0x03, 0xa3, 0xe5, 0x96, 0x49, 0x39, 0x3e, 0xdb, 0xe3, 0xf8, - 0x14, 0xa4, 0xfd, 0x3d, 0xc7, 0x4f, 0x7d, 0x6f, 0x37, 0x62, 0x37, 0xda, 0xac, 0xf7, 0x23, 0xee, - 0x58, 0xc5, 0xa6, 0xcd, 0x73, 0x79, 0x1f, 0x68, 0xeb, 0x0b, 0xf4, 0xe0, 0x69, 0xfb, 0x3e, 0x05, - 0xa3, 0xab, 0x46, 0xbd, 0x4e, 0x1c, 0xf4, 0x5b, 0xaf, 0x4a, 0xff, 0xd7, 0x63, 0x10, 0xc1, 0x98, - 0x6d, 0x59, 0xce, 0xb2, 0xe1, 0x6c, 0xf8, 0xcd, 0xdf, 0x1d, 0xa3, 0x6b, 0xc1, 0x2d, 0xe0, 0x7c, - 0x98, 0xac, 0xa3, 0xa1, 0x1c, 0x3d, 0x17, 0x43, 0x8b, 0x8c, 0x7a, 0x6a, 0x34, 0x49, 0xc3, 0x6a, - 0xd6, 0x2a, 0x7e, 0x76, 0xdd, 0x31, 0xfa, 0xa2, 0xcb, 0x64, 0x26, 0xc4, 0xa4, 0x10, 0xd9, 0x4b, - 0x3c, 0x2a, 0x4b, 0x3b, 0xd8, 0x46, 0x0f, 0xc1, 0x81, 0xbc, 0x28, 0x17, 0xa4, 0x9c, 0xae, 0xa9, - 0x7a, 0x16, 0x4b, 0xa2, 0x26, 0xe9, 0x05, 0x35, 0x2b, 0x16, 0x74, 0x2c, 0x2d, 0xab, 0x1c, 0xa1, - 0xdb, 0x40, 0x1a, 0x93, 0x8a, 0xb5, 0x49, 0x6c, 0x24, 0x46, 0x62, 0x78, 0x28, 0x27, 0x6f, 0x06, - 0xd9, 0xbf, 0x10, 0x66, 0xff, 0x58, 0x3f, 0x5e, 0x7c, 0xdf, 0x03, 0x8a, 0xf5, 0xcb, 0x2e, 0xc5, - 0xd9, 0x10, 0xc5, 0xa7, 0xa2, 0x43, 0x3d, 0x02, 0x1c, 0xbf, 0x35, 0x09, 0x69, 0xb1, 0x52, 0xb1, - 0x2e, 0x36, 0x1d, 0xf4, 0x21, 0xdb, 0x2d, 0xe8, 0x4b, 0x3d, 0xba, 0x79, 0x60, 0x9b, 0x46, 0x83, - 0xf8, 0x54, 0xbb, 0xdf, 0xfc, 0x31, 0xf8, 0x8f, 0xb1, 0x69, 0x38, 0x86, 0x5d, 0xb0, 0x2a, 0x46, - 0xdd, 0x55, 0xc2, 0x0d, 0x78, 0x69, 0x04, 0x6f, 0xff, 0x81, 0x9f, 0x83, 0x09, 0x6f, 0x2a, 0x6b, - 0xd5, 0x2d, 0xdb, 0xbd, 0x4b, 0x50, 0xbb, 0xe0, 0x64, 0x66, 0x0c, 0x46, 0xbd, 0x21, 0xba, 0x96, - 0x8c, 0x2a, 0x92, 0x1f, 0xf5, 0xf0, 0x1e, 0x39, 0x0d, 0x69, 0xc3, 0xb3, 0xf3, 0x4f, 0xc9, 0x7d, - 0xdb, 0x8e, 0x0d, 0x1f, 0x05, 0x77, 0xcc, 0xd0, 0x55, 0x26, 0x8a, 0xac, 0x43, 0x9d, 0xc7, 0x93, - 0xf5, 0x93, 0xc4, 0x0e, 0x74, 0x3d, 0x01, 0xf3, 0x62, 0x36, 0xab, 0x96, 0x15, 0xcd, 0x57, 0x35, - 0xa7, 0x67, 0xca, 0x9a, 0xde, 0xd3, 0xba, 0xa4, 0x89, 0x58, 0xd3, 0x15, 0x35, 0x27, 0x71, 0x54, - 0xae, 0x23, 0xf7, 0xb0, 0x96, 0x34, 0x5d, 0x11, 0x8b, 0x12, 0xb7, 0x1e, 0x01, 0x59, 0xd2, 0x74, - 0x71, 0x45, 0xd4, 0x44, 0xcc, 0x55, 0xd1, 0x57, 0xc9, 0x5e, 0x8b, 0x8e, 0x77, 0x6b, 0x06, 0x7d, - 0x10, 0x54, 0x51, 0x0c, 0xab, 0x78, 0xbc, 0x2f, 0x91, 0xc3, 0x7b, 0xed, 0xd7, 0xae, 0x28, 0xb9, - 0x90, 0x28, 0xa7, 0x63, 0x60, 0xc5, 0x53, 0xe5, 0x8f, 0x9d, 0xa8, 0xb2, 0x17, 0x76, 0x2b, 0xaa, - 0xee, 0xd3, 0x57, 0xd2, 0xf3, 0x6a, 0x59, 0xc9, 0x71, 0xd4, 0xdb, 0x41, 0x45, 0xf2, 0xc8, 0xc3, - 0x52, 0x56, 0x5d, 0x91, 0xb0, 0xbe, 0x2a, 0x16, 0x0a, 0x92, 0xa6, 0xe7, 0x65, 0x5c, 0xd2, 0xb8, - 0xf5, 0x7b, 0xb5, 0x69, 0x95, 0x3f, 0x0c, 0x87, 0x7a, 0x63, 0x5d, 0x7a, 0x56, 0x2e, 0x69, 0x25, - 0x57, 0x97, 0xac, 0x8a, 0x71, 0x79, 0x59, 0x93, 0x72, 0xdc, 0x06, 0xbf, 0x0f, 0xf8, 0x1e, 0x0a, - 0x2e, 0x2b, 0x9e, 0xfc, 0x35, 0xea, 0xdf, 0xf7, 0xd7, 0x71, 0x4f, 0xaf, 0xae, 0xcb, 0x12, 0xce, - 0xab, 0xb8, 0x28, 0xe5, 0xb8, 0x17, 0xd0, 0x15, 0x16, 0x46, 0x4b, 0xa4, 0x4e, 0x2a, 0x0e, 0x7a, - 0x7c, 0xf0, 0xeb, 0x21, 0xb8, 0xf1, 0x32, 0xdb, 0x8e, 0xb6, 0x9f, 0x62, 0xf7, 0xad, 0xe7, 0xef, - 0xbe, 0xf5, 0xed, 0x8f, 0xb1, 0xfa, 0xb6, 0xaf, 0xf3, 0x78, 0x15, 0x72, 0x33, 0xf1, 0x00, 0xf6, - 0xe3, 0x28, 0x42, 0xaf, 0x0f, 0x10, 0xba, 0x1a, 0x46, 0xcf, 0xcb, 0x4a, 0xae, 0x53, 0x8b, 0xba, - 0xac, 0xe4, 0x55, 0x6e, 0x83, 0x17, 0xe0, 0x58, 0x00, 0x9d, 0x56, 0x81, 0xef, 0x41, 0x54, 0x72, - 0x7a, 0x51, 0x91, 0x8a, 0xaa, 0x22, 0x67, 0xdd, 0xf9, 0x92, 0xa4, 0x71, 0x35, 0xf4, 0x33, 0x03, - 0xe9, 0x15, 0x62, 0xb7, 0x6b, 0x56, 0x13, 0x7d, 0xcb, 0x40, 0x72, 0x91, 0x38, 0xc1, 0x36, 0xbf, - 0x1e, 0x3c, 0x51, 0xcf, 0x85, 0x45, 0xff, 0x7f, 0x88, 0x77, 0x1f, 0x44, 0x58, 0x24, 0x83, 0x14, - 0x9f, 0x86, 0xf4, 0xa6, 0x67, 0xe4, 0x93, 0xdd, 0x19, 0xa2, 0x1f, 0xba, 0x07, 0xed, 0x85, 0x90, - 0xb2, 0x27, 0x22, 0x7a, 0x88, 0x27, 0xab, 0xb9, 0x03, 0x55, 0xf7, 0x00, 0xb7, 0x22, 0xe1, 0x92, - 0xac, 0x2a, 0xba, 0x5c, 0xd2, 0xa5, 0xe2, 0xb2, 0xf6, 0x1c, 0x97, 0xa4, 0x46, 0x94, 0xc9, 0xce, - 0x2e, 0x30, 0x01, 0x69, 0x4d, 0x2e, 0x4a, 0x6a, 0x59, 0xe3, 0xd6, 0xd1, 0xe7, 0x49, 0x48, 0x16, - 0xac, 0x2a, 0xba, 0x9e, 0x04, 0xb6, 0x44, 0x9a, 0x26, 0x7a, 0x3f, 0xd1, 0xeb, 0xbb, 0x69, 0x48, - 0x37, 0x48, 0xbb, 0x6d, 0x54, 0x3b, 0x87, 0x6e, 0x67, 0xc8, 0x3f, 0x01, 0xa9, 0x3a, 0xd9, 0x24, - 0x75, 0x37, 0xf0, 0xa9, 0x85, 0xc3, 0x21, 0x06, 0x0a, 0x56, 0x55, 0xa0, 0x58, 0x82, 0x8f, 0x23, - 0x14, 0xa8, 0x29, 0xf6, 0x56, 0xcc, 0x3d, 0x0d, 0x29, 0x77, 0xcc, 0x8f, 0x43, 0x2a, 0x27, 0x65, - 0xca, 0x8b, 0xdc, 0x08, 0xfd, 0xec, 0x64, 0x34, 0x0e, 0xa9, 0xbc, 0xa8, 0x89, 0x05, 0x8e, 0xa1, - 0x99, 0xbb, 0xe5, 0x92, 0xa4, 0x93, 0xcb, 0xa2, 0x22, 0x67, 0x39, 0x96, 0x46, 0xbf, 0x2a, 0x62, - 0x45, 0x56, 0x16, 0xb9, 0x14, 0x7a, 0x25, 0xa8, 0xfb, 0xd9, 0xb0, 0xee, 0xff, 0x1d, 0x14, 0xd3, - 0xf0, 0x27, 0xff, 0xb9, 0x90, 0xb4, 0x47, 0xa3, 0x80, 0xc4, 0xd3, 0x55, 0xd9, 0x81, 0xae, 0xc3, - 0x14, 0xfc, 0x87, 0x01, 0x56, 0x6e, 0xad, 0xb7, 0xd1, 0x5f, 0x7e, 0x5f, 0xdc, 0x61, 0x80, 0xcd, - 0xd7, 0xea, 0x64, 0xd8, 0x7f, 0x00, 0xdf, 0x44, 0x7e, 0x00, 0x50, 0x68, 0xb7, 0x96, 0x29, 0xe4, - 0x80, 0x96, 0xe1, 0x81, 0x35, 0x0d, 0xc7, 0x70, 0xb3, 0x9d, 0xc4, 0xee, 0x37, 0xbf, 0x07, 0x52, - 0x0d, 0x62, 0xd6, 0x0c, 0xef, 0x9e, 0x85, 0xbd, 0x41, 0xf7, 0x0e, 0xc7, 0xf6, 0xee, 0x70, 0xe8, - 0xd3, 0x48, 0x4f, 0x84, 0x61, 0x71, 0x3c, 0x5c, 0x01, 0x5e, 0x1b, 0x85, 0x94, 0xdc, 0x30, 0xaa, - 0x04, 0xfd, 0x9d, 0xf2, 0x14, 0xf8, 0x93, 0x01, 0x36, 0x53, 0xb7, 0xd6, 0xd0, 0xd2, 0xe0, 0x33, - 0xec, 0x24, 0xb0, 0xed, 0xda, 0x65, 0xe2, 0x37, 0xd0, 0xfe, 0x6d, 0xa7, 0x8a, 0x8b, 0x27, 0x94, - 0x6a, 0x97, 0x09, 0x76, 0xcd, 0xd0, 0xbb, 0x91, 0xdf, 0x0c, 0xde, 0x52, 0xca, 0x14, 0x0d, 0x61, - 0xb0, 0x62, 0x6b, 0x75, 0x6b, 0xad, 0xa3, 0x18, 0xfd, 0x46, 0x9f, 0x45, 0x7a, 0x47, 0x0c, 0x85, - 0x7f, 0xf8, 0x9d, 0xe0, 0x16, 0xfe, 0xfd, 0xa3, 0xfd, 0xea, 0x0e, 0x68, 0x1f, 0xd2, 0x28, 0x07, - 0x61, 0xbc, 0x1e, 0x7e, 0xa8, 0xe0, 0xde, 0x44, 0x6c, 0x01, 0x1e, 0xb5, 0x4e, 0xc8, 0x1c, 0xfc, - 0xfa, 0xd6, 0x4c, 0xe2, 0xc6, 0xad, 0x99, 0xc4, 0xef, 0xb7, 0x66, 0x12, 0x6f, 0xdc, 0x9e, 0x19, - 0xb9, 0x71, 0x7b, 0x66, 0xe4, 0x97, 0xdb, 0x33, 0x23, 0xcf, 0x33, 0xad, 0xb5, 0xb5, 0x51, 0xf7, - 0xcf, 0xe3, 0x33, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x83, 0x77, 0x03, 0x72, 0x74, 0x16, 0x00, - 0x00, + // 1511 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0x4d, 0x8c, 0xdb, 0xd4, + 0x16, 0xc7, 0x27, 0x8e, 0x33, 0x99, 0x39, 0x33, 0x9d, 0xe7, 0x5a, 0x7d, 0xd5, 0xf4, 0xbe, 0x6a, + 0x5a, 0x4d, 0xdf, 0xeb, 0x9b, 0x4e, 0x5b, 0x53, 0x4d, 0xc5, 0x02, 0x44, 0x69, 0x9d, 0xc4, 0x99, + 0x1a, 0x12, 0x3b, 0xba, 0x71, 0x66, 0x00, 0x09, 0x59, 0x9e, 0xe4, 0x4e, 0xc6, 0xe0, 0xc4, 0xc1, + 0x71, 0xa7, 0xb4, 0x3b, 0x16, 0x88, 0x05, 0x42, 0x42, 0x48, 0xac, 0x90, 0x10, 0x6c, 0x69, 0x91, + 0xd8, 0x15, 0x21, 0x51, 0xa4, 0xc2, 0x02, 0x90, 0x90, 0x0a, 0x48, 0x80, 0x90, 0x40, 0xb4, 0x5d, + 0x21, 0xd4, 0x1d, 0x2c, 0x58, 0x80, 0xd0, 0xb5, 0x9d, 0xc4, 0x1e, 0x4d, 0x52, 0x7b, 0xd4, 0xaa, + 0xdd, 0xf9, 0xde, 0xdc, 0x7b, 0xce, 0xb9, 0xbf, 0xff, 0x39, 0xf7, 0x23, 0x30, 0x53, 0xb7, 0x5b, + 0x2d, 0xa3, 0xdd, 0xe8, 0x0a, 0x1d, 0xc7, 0x76, 0x6d, 0x3e, 0x6b, 0xb4, 0x2f, 0xb8, 0x17, 0x3a, + 0x04, 0x4d, 0xb7, 0xec, 0x06, 0xb1, 0x82, 0x6e, 0xb4, 0xab, 0xbe, 0x61, 0xb4, 0x9b, 0x24, 0x68, + 0xce, 0xff, 0x78, 0x14, 0xd2, 0xb8, 0x53, 0x47, 0x57, 0x01, 0x32, 0x39, 0xcb, 0xae, 0x3f, 0x8f, + 0x5e, 0x4e, 0x43, 0xf6, 0xac, 0xd9, 0x75, 0x6d, 0xe7, 0x02, 0xfa, 0x93, 0x01, 0xb6, 0x6c, 0x6f, + 0x12, 0x54, 0x87, 0x2c, 0x26, 0x2f, 0x9c, 0x23, 0x5d, 0x97, 0x9f, 0x01, 0xc6, 0x6c, 0xcc, 0xa6, + 0x0e, 0xa6, 0x16, 0x26, 0x31, 0x63, 0x36, 0xf8, 0xc3, 0xd4, 0x73, 0xdb, 0x25, 0x2f, 0xba, 0xde, + 0x7c, 0xb9, 0x31, 0xcb, 0x78, 0xbf, 0x6d, 0xe9, 0xe5, 0x0f, 0xc2, 0x54, 0xcb, 0xde, 0x24, 0x45, + 0xdb, 0x39, 0x6f, 0x38, 0x8d, 0xd9, 0xf4, 0xc1, 0xd4, 0xc2, 0x04, 0x0e, 0x77, 0xa1, 0x57, 0x19, + 0x98, 0xc0, 0xa4, 0xdb, 0xb1, 0xdb, 0x5d, 0xc2, 0x17, 0x20, 0x43, 0x1c, 0xc7, 0x76, 0x3c, 0x4f, + 0x53, 0x4b, 0x82, 0x10, 0x2c, 0x47, 0xc0, 0x9d, 0xba, 0xe0, 0xd9, 0x14, 0x82, 0x28, 0x05, 0x1a, + 0xa1, 0xd0, 0x9b, 0x28, 0x48, 0x74, 0x16, 0xf6, 0x27, 0xa3, 0x0f, 0x53, 0x90, 0xf1, 0x3a, 0xf8, + 0x65, 0x60, 0xeb, 0x76, 0x83, 0x78, 0xe6, 0x66, 0x96, 0x4e, 0x26, 0x33, 0x27, 0xe4, 0xed, 0x06, + 0xc1, 0x9e, 0x01, 0xba, 0x8e, 0x06, 0xe9, 0xd6, 0x1d, 0xb3, 0xe3, 0x9a, 0x76, 0x3b, 0x58, 0x6c, + 0xb8, 0x6b, 0xbe, 0x00, 0x2c, 0x1d, 0xcf, 0x4f, 0x00, 0xab, 0xd4, 0x4a, 0x25, 0x6e, 0x8c, 0xdf, + 0x0d, 0xbb, 0x6a, 0xca, 0x93, 0x8a, 0xba, 0xaa, 0xe8, 0x12, 0xc6, 0x2a, 0xe6, 0x52, 0xfc, 0x2e, + 0x98, 0xcc, 0x89, 0x05, 0x5d, 0x56, 0x2a, 0x35, 0x8d, 0x63, 0x78, 0x0e, 0xa6, 0xf3, 0xa2, 0xa2, + 0x2b, 0xaa, 0xa6, 0x97, 0xd5, 0x15, 0x89, 0x4b, 0xa3, 0xd7, 0x18, 0x60, 0xd5, 0x0e, 0x69, 0xa3, + 0x7d, 0x43, 0xd9, 0xa3, 0x5f, 0x53, 0x21, 0x62, 0x8f, 0x45, 0x89, 0x1d, 0xde, 0x66, 0x89, 0xd4, + 0xde, 0x10, 0x52, 0x6f, 0xf7, 0x49, 0x9d, 0x8e, 0x90, 0x3a, 0x1a, 0xcf, 0x4c, 0x32, 0x42, 0x4b, + 0xc9, 0x09, 0xa1, 0xef, 0x19, 0x18, 0xcf, 0x3b, 0xc4, 0x70, 0x09, 0x7a, 0x76, 0x40, 0x64, 0x11, + 0x32, 0x6b, 0x34, 0xa6, 0x60, 0xd1, 0x7b, 0xfa, 0xd1, 0x96, 0x69, 0xd2, 0xfb, 0xf1, 0x62, 0x7f, + 0x48, 0xdc, 0x4c, 0x45, 0xb7, 0xc3, 0x54, 0x1f, 0x8f, 0x52, 0x5d, 0xd8, 0x06, 0x87, 0x1f, 0xd5, + 0x10, 0xae, 0xef, 0xf4, 0xb9, 0x8a, 0x11, 0xae, 0xc7, 0xe3, 0x1a, 0xba, 0xf7, 0x64, 0xaf, 0x31, + 0x30, 0x5e, 0xeb, 0x34, 0x28, 0xd9, 0xb3, 0x03, 0xb2, 0xa7, 0x20, 0x1b, 0x6c, 0x15, 0xc1, 0xd2, + 0x0f, 0xf5, 0x23, 0xce, 0x7b, 0xfd, 0x42, 0xf9, 0x9c, 0xe5, 0x9a, 0x1d, 0x8b, 0xf8, 0xd1, 0x77, + 0x4b, 0x66, 0xd7, 0xc5, 0xbd, 0x39, 0x89, 0x21, 0xfa, 0x01, 0xdc, 0x05, 0x88, 0xdb, 0x1a, 0xba, + 0xf7, 0x10, 0xbf, 0xca, 0xc0, 0xf8, 0xaa, 0x61, 0x59, 0xc4, 0x45, 0x3f, 0x0f, 0x32, 0xf5, 0x7f, + 0x03, 0x9e, 0x08, 0x26, 0x1c, 0xdb, 0x76, 0x2b, 0x86, 0xbb, 0x11, 0x54, 0x70, 0xbf, 0x8d, 0x2e, + 0x87, 0x77, 0xbe, 0xd3, 0x51, 0x58, 0x47, 0x22, 0x6b, 0xf4, 0x5d, 0x8c, 0x4c, 0x39, 0xea, 0xa9, + 0xd5, 0x26, 0x2d, 0xbb, 0x6d, 0xd6, 0x83, 0xd5, 0xf5, 0xdb, 0xe8, 0x5a, 0x9f, 0x64, 0x2e, 0x42, + 0x52, 0x88, 0xed, 0x25, 0x19, 0xca, 0xea, 0x0e, 0xf6, 0xc2, 0x03, 0xf0, 0x9f, 0xa2, 0x28, 0x97, + 0xa4, 0x82, 0xae, 0xa9, 0x7a, 0x1e, 0x4b, 0xa2, 0x26, 0xe9, 0x25, 0x35, 0x2f, 0x96, 0x74, 0x2c, + 0x55, 0x54, 0x8e, 0xa0, 0x1b, 0x0c, 0xc5, 0x5a, 0xb7, 0x37, 0x89, 0x83, 0xc4, 0x58, 0x84, 0x47, + 0x32, 0x79, 0x23, 0x4c, 0xff, 0x4c, 0x94, 0xfe, 0xe2, 0x76, 0x5c, 0x02, 0xdf, 0x43, 0x92, 0xf5, + 0xd3, 0x3e, 0xe2, 0x7c, 0x04, 0xf1, 0x43, 0xf1, 0x4d, 0x3d, 0x00, 0x8c, 0xdf, 0x9a, 0x86, 0xac, + 0x58, 0xaf, 0xdb, 0xe7, 0xda, 0x2e, 0xfa, 0x80, 0xed, 0x27, 0xf4, 0xf9, 0x01, 0x6e, 0x1e, 0xd8, + 0xb6, 0xd1, 0x22, 0x01, 0x6a, 0xef, 0x9b, 0x5f, 0x84, 0x7f, 0x19, 0x9b, 0x86, 0x6b, 0x38, 0x25, + 0xbb, 0x6e, 0x58, 0x9e, 0x12, 0x5e, 0xc0, 0x67, 0xc7, 0xf0, 0xd6, 0x1f, 0xf8, 0x79, 0x98, 0xf2, + 0xbb, 0xf2, 0xb6, 0x65, 0x3b, 0xde, 0x85, 0x80, 0x8e, 0x0b, 0x77, 0xe6, 0x26, 0x60, 0xdc, 0x6f, + 0xa2, 0xcb, 0xe9, 0xb8, 0x22, 0x05, 0x51, 0x8f, 0xae, 0x91, 0x13, 0x90, 0x35, 0xfc, 0x71, 0x5e, + 0x80, 0x53, 0x4b, 0x7b, 0xb7, 0x9c, 0x1c, 0x81, 0x15, 0xdc, 0x1b, 0x86, 0x2e, 0x31, 0x71, 0x64, + 0x1d, 0xe9, 0x3c, 0x99, 0xac, 0x1f, 0xa5, 0x76, 0xa0, 0xeb, 0x31, 0x58, 0x10, 0xf3, 0x79, 0xb5, + 0xa6, 0x68, 0x81, 0xaa, 0x05, 0x3d, 0x57, 0xd3, 0xf4, 0x81, 0xd6, 0x55, 0x4d, 0xc4, 0x9a, 0xae, + 0xa8, 0x05, 0x89, 0xa3, 0x72, 0x1d, 0xbe, 0xc3, 0x68, 0x49, 0xd3, 0x15, 0xb1, 0x2c, 0x71, 0xeb, + 0x31, 0x2c, 0x4b, 0x9a, 0x2e, 0xae, 0x88, 0x9a, 0x88, 0xb9, 0x26, 0xfa, 0x2c, 0x3d, 0x28, 0xd1, + 0xc9, 0x7e, 0xce, 0xa0, 0xf7, 0xc3, 0x2a, 0x8a, 0x51, 0x15, 0x8f, 0x6e, 0x0b, 0x72, 0x74, 0xad, + 0xfd, 0xd4, 0x17, 0xa5, 0x10, 0x11, 0xe5, 0x44, 0x02, 0x5b, 0xc9, 0x54, 0xf9, 0x6d, 0x27, 0xaa, + 0xfc, 0x1b, 0x76, 0x2b, 0xaa, 0x1e, 0xe0, 0xab, 0xea, 0x45, 0xb5, 0xa6, 0x14, 0x38, 0xea, 0x6d, + 0xbf, 0x22, 0xf9, 0xf0, 0xb0, 0x94, 0x57, 0x57, 0x24, 0xac, 0xaf, 0x8a, 0xa5, 0x92, 0xa4, 0xe9, + 0x45, 0x19, 0x57, 0x35, 0x6e, 0xfd, 0x4e, 0x65, 0xda, 0xe4, 0x0f, 0xc1, 0x81, 0x41, 0x5b, 0x97, + 0x9e, 0x92, 0xab, 0x5a, 0xd5, 0xd3, 0x25, 0xaf, 0x62, 0x5c, 0xab, 0x68, 0x52, 0x81, 0xdb, 0xe0, + 0xf7, 0x02, 0x3f, 0xb0, 0x82, 0x6b, 0x8a, 0x2f, 0xbf, 0x49, 0xfd, 0x07, 0xfe, 0x7a, 0xee, 0xe9, + 0xfd, 0xb3, 0x22, 0xe1, 0xa2, 0x8a, 0xcb, 0x52, 0x81, 0x7b, 0x0e, 0xbd, 0xc9, 0xc2, 0x78, 0x95, + 0x58, 0xa4, 0xee, 0xa2, 0x87, 0x87, 0x3f, 0x01, 0xc2, 0x1b, 0x2f, 0xb3, 0xe5, 0x68, 0xfb, 0x36, + 0x71, 0xdd, 0xfa, 0xfe, 0xee, 0x5a, 0xdd, 0x7e, 0x93, 0xa8, 0x6e, 0xb7, 0x75, 0x9e, 0x2c, 0x43, + 0x6e, 0xa4, 0xee, 0xc1, 0x7e, 0x1c, 0x47, 0xe8, 0xf5, 0x21, 0x42, 0x37, 0xa3, 0xd6, 0x8b, 0xb2, + 0x52, 0xe8, 0xe5, 0xa2, 0x2e, 0x2b, 0x45, 0x95, 0xdb, 0xe0, 0x05, 0x58, 0x0c, 0x59, 0xa7, 0x59, + 0x10, 0x78, 0x10, 0x95, 0x82, 0x5e, 0x56, 0xa4, 0xb2, 0xaa, 0xc8, 0x79, 0xaf, 0xbf, 0x2a, 0x69, + 0x9c, 0x89, 0xbe, 0x63, 0x20, 0xbb, 0x42, 0x9c, 0xae, 0x69, 0xb7, 0xd1, 0x97, 0x0c, 0xa4, 0x97, + 0x89, 0x1b, 0x2e, 0xf3, 0x2b, 0xe1, 0x13, 0xf5, 0x54, 0x54, 0xf4, 0xff, 0x47, 0xb8, 0x07, 0x46, + 0x84, 0x65, 0x32, 0x4c, 0xf1, 0x59, 0xc8, 0x6e, 0xfa, 0x83, 0x02, 0xd8, 0xbd, 0x26, 0xfa, 0xba, + 0x7f, 0xd0, 0x9e, 0x89, 0x28, 0x7b, 0x2c, 0xa6, 0x87, 0x64, 0xb2, 0x36, 0x76, 0xa0, 0xea, 0x1e, + 0xe0, 0x56, 0x24, 0x5c, 0x95, 0x55, 0x45, 0x97, 0xab, 0xba, 0x54, 0xae, 0x68, 0x4f, 0x73, 0x69, + 0x3a, 0x88, 0x92, 0xec, 0xed, 0x02, 0x53, 0x90, 0xd5, 0xe4, 0xb2, 0xa4, 0xd6, 0x34, 0x6e, 0x1d, + 0x7d, 0x92, 0x86, 0x74, 0xc9, 0x6e, 0xa2, 0x2b, 0x69, 0x60, 0xab, 0xa4, 0xdd, 0x40, 0xef, 0xa5, + 0x06, 0x75, 0x37, 0x0b, 0xd9, 0x16, 0xe9, 0x76, 0x8d, 0x66, 0xef, 0xd0, 0xed, 0x35, 0xf9, 0x47, + 0x20, 0x63, 0x91, 0x4d, 0x62, 0x79, 0x81, 0xcf, 0x84, 0xae, 0xea, 0x94, 0x40, 0xc9, 0x6e, 0x0a, + 0xd4, 0x96, 0x10, 0xd8, 0x11, 0x4a, 0x74, 0x28, 0xf6, 0x67, 0xcc, 0x3f, 0x01, 0x19, 0xaf, 0xcd, + 0x4f, 0x42, 0xa6, 0x20, 0xe5, 0x6a, 0xcb, 0xdc, 0x18, 0xfd, 0xec, 0xad, 0x68, 0x12, 0x32, 0x45, + 0x51, 0x13, 0x4b, 0x1c, 0x43, 0x57, 0xee, 0xa5, 0x4b, 0x9a, 0x76, 0x56, 0x44, 0x45, 0xce, 0x73, + 0x2c, 0x8d, 0x7e, 0x55, 0xc4, 0x8a, 0xac, 0x2c, 0x73, 0x19, 0xf4, 0x52, 0x58, 0xf7, 0x47, 0xa3, + 0xba, 0xff, 0x77, 0x58, 0x4c, 0xa3, 0xdf, 0xed, 0xa7, 0x22, 0xd2, 0x1e, 0x89, 0x63, 0x24, 0x99, + 0xae, 0xca, 0x0e, 0x74, 0x1d, 0xa5, 0xe0, 0xdf, 0x0c, 0xb0, 0x72, 0x67, 0xbd, 0x8b, 0xfe, 0x08, + 0xea, 0xe2, 0x36, 0x03, 0x6c, 0xd1, 0xb4, 0xc8, 0xa8, 0x87, 0xfc, 0x17, 0xb1, 0x1f, 0x00, 0xd4, + 0xb4, 0x97, 0xcb, 0xd4, 0xe4, 0x90, 0x92, 0xe1, 0x81, 0x6d, 0x18, 0xae, 0xe1, 0xad, 0x76, 0x1a, + 0x7b, 0xdf, 0xfc, 0x1e, 0xc8, 0xb4, 0x48, 0xc3, 0x34, 0xfc, 0x7b, 0x16, 0xf6, 0x1b, 0xfd, 0x3b, + 0x1c, 0x3b, 0xb8, 0xc3, 0xa1, 0x8f, 0x63, 0x3d, 0x11, 0x46, 0xc5, 0x71, 0x7f, 0x05, 0x78, 0x65, + 0x1c, 0x32, 0x72, 0xcb, 0x68, 0x12, 0xf4, 0x57, 0xc6, 0x57, 0xe0, 0x77, 0x06, 0xd8, 0x9c, 0x65, + 0xaf, 0x85, 0x9f, 0xb7, 0x5b, 0xcf, 0xb0, 0xe3, 0xc0, 0x76, 0xcd, 0x8b, 0x24, 0x28, 0xa0, 0x7d, + 0x5b, 0x4e, 0x15, 0xcf, 0x9e, 0x50, 0x35, 0x2f, 0x12, 0xec, 0x0d, 0x43, 0xef, 0xc6, 0x7e, 0x33, + 0xf8, 0x53, 0x29, 0x29, 0x1a, 0xc2, 0x70, 0xc5, 0xd6, 0x2c, 0x7b, 0xad, 0xa7, 0x18, 0xfd, 0x46, + 0x57, 0x63, 0xbd, 0x23, 0x46, 0x9a, 0xbf, 0xff, 0x95, 0xe0, 0x25, 0xfe, 0xdd, 0xc3, 0x7e, 0x69, + 0x07, 0xd8, 0x47, 0x14, 0xca, 0x7e, 0x98, 0xb4, 0xa2, 0x0f, 0x15, 0x3c, 0xe8, 0x48, 0x2c, 0xc0, + 0x83, 0x56, 0x09, 0xb9, 0xfd, 0x9f, 0xdf, 0x9c, 0x4b, 0x5d, 0xbf, 0x39, 0x97, 0xfa, 0xe5, 0xe6, + 0x5c, 0xea, 0xf5, 0x5b, 0x73, 0x63, 0xd7, 0x6f, 0xcd, 0x8d, 0xfd, 0x70, 0x6b, 0x6e, 0xec, 0x19, + 0xa6, 0xb3, 0xb6, 0x36, 0xee, 0xfd, 0x03, 0x7c, 0xf2, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe8, + 0x3d, 0xdc, 0x1e, 0x39, 0x16, 0x00, 0x00, } func (m *Rpc) Marshal() (dAtA []byte, err error) { @@ -4063,18 +4054,6 @@ func (m *RpcBlockOpenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.BlockHeader != nil { - { - size, err := m.BlockHeader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintCommands(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } if m.Error != nil { { size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) @@ -4175,10 +4154,17 @@ func (m *RpcBlockCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if m.Type != 0 { - i = encodeVarintCommands(dAtA, i, uint64(m.Type)) + if m.Block != nil { + { + size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCommands(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } @@ -6048,10 +6034,6 @@ func (m *RpcBlockOpenResponse) Size() (n int) { l = m.Error.Size() n += 1 + l + sovCommands(uint64(l)) } - if m.BlockHeader != nil { - l = m.BlockHeader.Size() - n += 1 + l + sovCommands(uint64(l)) - } return n } @@ -6086,8 +6068,9 @@ func (m *RpcBlockCreateRequest) Size() (n int) { } var l int _ = l - if m.Type != 0 { - n += 1 + sovCommands(uint64(m.Type)) + if m.Block != nil { + l = m.Block.Size() + n += 1 + l + sovCommands(uint64(l)) } l = len(m.ContextBlockId) if l > 0 { @@ -7577,42 +7560,6 @@ func (m *RpcBlockOpenResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockHeader", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowCommands - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthCommands - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthCommands - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.BlockHeader == nil { - m.BlockHeader = &ModelBlockHeader{} - } - if err := m.BlockHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommands(dAtA[iNdEx:]) @@ -7824,10 +7771,10 @@ func (m *RpcBlockCreateRequest) Unmarshal(dAtA []byte) error { } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) } - m.Type = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCommands @@ -7837,11 +7784,28 @@ func (m *RpcBlockCreateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= ModelBlockHeaderType(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthCommands + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCommands + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Block == nil { + m.Block = &ModelBlock{} + } + if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContextBlockId", wireType) @@ -8203,7 +8167,7 @@ func (m *RpcBlockUpdateRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Changes == nil { - m.Changes = &BlockChanges{} + m.Changes = &ChangeMultipleBlocksList{} } if err := m.Changes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err diff --git a/pb/events.pb.go b/pb/events.pb.go index b1ed9efb0..d31b93071 100644 --- a/pb/events.pb.go +++ b/pb/events.pb.go @@ -369,7 +369,7 @@ func (m *EventBlockShow) GetBlock() *ModelBlock { } type EventBlockUpdate struct { - Changes *BlockChanges `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"` + Changes *ChangeMultipleBlocksList `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"` } func (m *EventBlockUpdate) Reset() { *m = EventBlockUpdate{} } @@ -405,7 +405,7 @@ func (m *EventBlockUpdate) XXX_DiscardUnknown() { var xxx_messageInfo_EventBlockUpdate proto.InternalMessageInfo -func (m *EventBlockUpdate) GetChanges() *BlockChanges { +func (m *EventBlockUpdate) GetChanges() *ChangeMultipleBlocksList { if m != nil { return m.Changes } @@ -825,43 +825,44 @@ func init() { func init() { proto.RegisterFile("events.proto", fileDescriptor_8f22242cb04491f9) } var fileDescriptor_8f22242cb04491f9 = []byte{ - // 567 bytes of a gzipped FileDescriptorProto + // 579 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0xcf, 0x6e, 0xd3, 0x40, - 0x10, 0xc6, 0xed, 0xfc, 0x73, 0x3d, 0x6e, 0x2e, 0xab, 0x80, 0xcc, 0x82, 0xac, 0x88, 0x3f, 0x52, - 0xc5, 0xc1, 0xa0, 0xc2, 0xa1, 0x3d, 0xa1, 0x26, 0x50, 0x05, 0x04, 0x08, 0x6d, 0xc9, 0x01, 0x38, - 0x39, 0xf6, 0xb6, 0x89, 0x70, 0x6d, 0xcb, 0x76, 0xa1, 0x39, 0xf3, 0x02, 0x3c, 0x16, 0xc7, 0x1e, - 0xb9, 0x20, 0xa1, 0xe4, 0xc2, 0xb5, 0x6f, 0x80, 0x76, 0xbc, 0x76, 0xec, 0xc8, 0x01, 0xe5, 0x38, - 0xe3, 0xef, 0xfb, 0x4d, 0x76, 0xf6, 0xdb, 0xc0, 0x2e, 0xff, 0xc2, 0x83, 0x34, 0xb1, 0xa3, 0x38, - 0x4c, 0x43, 0xa2, 0x39, 0xc1, 0x3c, 0x9d, 0x47, 0x9c, 0xee, 0x9e, 0x87, 0x1e, 0xf7, 0x65, 0x9b, - 0x76, 0xdd, 0xa9, 0x13, 0x9c, 0x71, 0x59, 0xde, 0xfd, 0x05, 0xd0, 0x7e, 0x21, 0x6c, 0xe4, 0x19, - 0x18, 0x8e, 0xeb, 0x86, 0x17, 0x41, 0x7a, 0x32, 0x0d, 0xbf, 0x9a, 0x6a, 0x5f, 0xdd, 0x33, 0xf6, - 0x6f, 0xdb, 0x92, 0x62, 0xa3, 0xc8, 0x3e, 0xca, 0x14, 0xb6, 0x90, 0x8c, 0x14, 0x56, 0x76, 0x90, - 0x43, 0xd0, 0x27, 0x7e, 0xe8, 0x7e, 0x46, 0x7b, 0x03, 0xed, 0xb7, 0xd6, 0xec, 0x03, 0xf1, 0x3d, - 0x37, 0xaf, 0xd4, 0x62, 0x36, 0x16, 0xe3, 0xc8, 0x73, 0x52, 0x6e, 0x36, 0x6b, 0x67, 0x67, 0xe6, - 0x4c, 0x22, 0x66, 0x97, 0x1c, 0x05, 0x60, 0x18, 0x73, 0x01, 0x68, 0xfd, 0x03, 0x90, 0x49, 0x0a, - 0x40, 0x56, 0x92, 0x31, 0x90, 0x8b, 0x84, 0xc7, 0x28, 0x79, 0xcf, 0x2f, 0x53, 0x26, 0x96, 0x64, - 0xb6, 0x91, 0x73, 0x6f, 0x8d, 0x33, 0x4e, 0x78, 0x2c, 0x61, 0x85, 0x74, 0xa4, 0xb0, 0x1a, 0x00, - 0x39, 0x86, 0x6e, 0xd1, 0x7d, 0x15, 0xce, 0x02, 0xb3, 0x83, 0x44, 0x6b, 0x33, 0x51, 0xa8, 0x46, - 0x0a, 0xab, 0xda, 0x2a, 0x9c, 0xd7, 0xfc, 0x34, 0x35, 0xb5, 0xff, 0x71, 0x84, 0xaa, 0xc2, 0x11, - 0x0d, 0xf2, 0x09, 0x7a, 0x45, 0xe3, 0x84, 0xfb, 0xdc, 0x95, 0x07, 0xdd, 0x41, 0xdc, 0x83, 0xcd, - 0xb8, 0x92, 0x78, 0xa4, 0xb0, 0x5a, 0x08, 0x79, 0x0e, 0xc6, 0xe9, 0xcc, 0xe7, 0xc9, 0x38, 0xf2, - 0x43, 0xc7, 0x33, 0x75, 0x64, 0xf6, 0x6b, 0x2f, 0xe1, 0x78, 0xa5, 0x13, 0x37, 0x51, 0xb2, 0xd1, - 0x0f, 0xa0, 0xc9, 0x94, 0xd1, 0xb7, 0xd0, 0xc2, 0x78, 0xf4, 0xa0, 0x3d, 0x0b, 0x3c, 0x7e, 0x89, - 0xa1, 0x6c, 0xb2, 0xac, 0x20, 0x8f, 0x41, 0x93, 0xf1, 0x93, 0x69, 0xbb, 0x59, 0x8c, 0x7a, 0x23, - 0x12, 0x9f, 0x87, 0x95, 0xe5, 0x32, 0x7a, 0xad, 0x42, 0x1b, 0xe7, 0xd3, 0x7d, 0x49, 0x7e, 0x08, - 0x6d, 0x4c, 0x81, 0x8c, 0x7b, 0x6f, 0x8d, 0x80, 0x62, 0x96, 0x49, 0xe8, 0x21, 0x74, 0x64, 0xda, - 0x1e, 0x81, 0x26, 0x5f, 0x91, 0xf4, 0xdd, 0x28, 0x7c, 0xe8, 0x18, 0x66, 0x1f, 0x59, 0xae, 0xa2, - 0x4f, 0xa1, 0x23, 0x73, 0xb6, 0xcd, 0xc0, 0x21, 0x18, 0xa5, 0x3d, 0x11, 0x0a, 0x3b, 0x62, 0x4f, - 0xef, 0x9c, 0x74, 0x6a, 0xaa, 0xfd, 0xe6, 0x9e, 0xce, 0x8a, 0x9a, 0x98, 0xa0, 0xa1, 0xe7, 0xa5, - 0x87, 0xbb, 0xd0, 0x59, 0x5e, 0xd2, 0xeb, 0x06, 0xb4, 0xc4, 0x3d, 0xd2, 0x3f, 0x8d, 0xfc, 0xf0, - 0x07, 0xd0, 0xc2, 0x50, 0x95, 0x16, 0xa8, 0xae, 0x2d, 0xb0, 0xf2, 0xda, 0x57, 0x0b, 0x3c, 0x80, - 0x16, 0xc6, 0x68, 0x7b, 0xe7, 0x37, 0x15, 0xf4, 0xd5, 0xb3, 0xd8, 0xda, 0xbf, 0xf9, 0x80, 0x62, - 0xa3, 0x31, 0x66, 0xb8, 0x59, 0xbb, 0x51, 0x1c, 0xc8, 0x32, 0x09, 0xe5, 0x60, 0x94, 0x03, 0xbb, - 0xfd, 0xcf, 0xb8, 0x0f, 0x5d, 0x39, 0x37, 0x39, 0x8a, 0x63, 0x67, 0x6e, 0x36, 0xf0, 0x22, 0xaa, - 0xcd, 0x81, 0x0e, 0xda, 0x39, 0x4f, 0x12, 0xe7, 0x8c, 0x0f, 0xee, 0xfc, 0x58, 0x58, 0xea, 0xd5, - 0xc2, 0x52, 0x7f, 0x2f, 0x2c, 0xf5, 0xfb, 0xd2, 0x52, 0xae, 0x96, 0x96, 0xf2, 0x73, 0x69, 0x29, - 0x1f, 0x1b, 0xd1, 0x64, 0xd2, 0xc1, 0x3f, 0xe1, 0x27, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xad, - 0x8b, 0xe3, 0x03, 0xba, 0x05, 0x00, 0x00, + 0x10, 0xc6, 0xed, 0xfc, 0x73, 0x3d, 0x69, 0x2e, 0xab, 0x08, 0x99, 0x05, 0x59, 0x11, 0x7f, 0xa4, + 0x8a, 0x83, 0x85, 0x0a, 0x87, 0x72, 0x40, 0xa8, 0x09, 0x94, 0x80, 0x5a, 0x84, 0xb6, 0xe4, 0x00, + 0x9c, 0x9c, 0x64, 0xdb, 0x44, 0xb8, 0xb6, 0x65, 0x6f, 0xa0, 0x39, 0xf3, 0x02, 0x3c, 0x16, 0xc7, + 0x1e, 0x39, 0xa2, 0xe4, 0x82, 0xc4, 0x89, 0x27, 0x00, 0xed, 0x78, 0xed, 0xd8, 0x91, 0x43, 0x95, + 0xe3, 0x4c, 0xbe, 0xef, 0x37, 0xd9, 0xd9, 0x6f, 0x0d, 0xbb, 0xfc, 0x33, 0xf7, 0x45, 0xec, 0x84, + 0x51, 0x20, 0x02, 0x62, 0xb8, 0xfe, 0x5c, 0xcc, 0x43, 0x4e, 0x77, 0x2f, 0x82, 0x31, 0xf7, 0x54, + 0x9b, 0xb6, 0x46, 0x13, 0xd7, 0x3f, 0xe7, 0xaa, 0xbc, 0xf3, 0x1b, 0xa0, 0xfe, 0x42, 0xda, 0xc8, + 0x33, 0x68, 0xba, 0xa3, 0x51, 0x30, 0xf3, 0xc5, 0xe9, 0x24, 0xf8, 0x62, 0xe9, 0x1d, 0x7d, 0xaf, + 0xb9, 0x7f, 0xcb, 0x51, 0x14, 0x07, 0x45, 0xce, 0x61, 0xa2, 0x70, 0xa4, 0xa4, 0xaf, 0xb1, 0xbc, + 0x83, 0x3c, 0x01, 0x73, 0xe8, 0x05, 0xa3, 0x4f, 0x68, 0xaf, 0xa0, 0xfd, 0xe6, 0x9a, 0xbd, 0x2b, + 0x7f, 0x4f, 0xcd, 0x2b, 0xb5, 0x9c, 0x8d, 0xc5, 0x20, 0x1c, 0xbb, 0x82, 0x5b, 0xd5, 0xd2, 0xd9, + 0x89, 0x39, 0x91, 0xc8, 0xd9, 0x39, 0x47, 0x06, 0xe8, 0x45, 0x5c, 0x02, 0x6a, 0xff, 0x01, 0x24, + 0x92, 0x0c, 0x90, 0x94, 0x64, 0x00, 0x64, 0x16, 0xf3, 0x08, 0x25, 0xef, 0xf8, 0xa5, 0x60, 0x72, + 0x49, 0x56, 0x1d, 0x39, 0x77, 0xd7, 0x38, 0x83, 0x98, 0x47, 0x0a, 0x96, 0x49, 0xfb, 0x1a, 0x2b, + 0x01, 0x90, 0x23, 0x68, 0x65, 0xdd, 0xd7, 0xc1, 0xd4, 0xb7, 0x1a, 0x48, 0xb4, 0x37, 0x13, 0xa5, + 0xaa, 0xaf, 0xb1, 0xa2, 0xad, 0xc0, 0x39, 0xe6, 0x67, 0xc2, 0x32, 0xae, 0xe3, 0x48, 0x55, 0x81, + 0x23, 0x1b, 0xe4, 0x23, 0xb4, 0xb3, 0xc6, 0x29, 0xf7, 0xf8, 0x48, 0x1d, 0x74, 0x07, 0x71, 0xf7, + 0x37, 0xe3, 0x72, 0xe2, 0xbe, 0xc6, 0x4a, 0x21, 0xe4, 0x39, 0x34, 0xcf, 0xa6, 0x1e, 0x8f, 0x07, + 0xa1, 0x17, 0xb8, 0x63, 0xcb, 0x44, 0x66, 0xa7, 0xf4, 0x12, 0x8e, 0x56, 0x3a, 0x79, 0x13, 0x39, + 0x1b, 0x7d, 0x0f, 0x86, 0x4a, 0x19, 0x7d, 0x03, 0x35, 0x8c, 0x47, 0x1b, 0xea, 0x53, 0x7f, 0xcc, + 0x2f, 0x31, 0x94, 0x55, 0x96, 0x14, 0xe4, 0x21, 0x18, 0x2a, 0x7e, 0x2a, 0x6d, 0x37, 0xb2, 0x51, + 0x27, 0x32, 0xf1, 0x69, 0x58, 0x59, 0x2a, 0xa3, 0x7f, 0x75, 0xa8, 0xe3, 0x7c, 0xba, 0xaf, 0xc8, + 0x0f, 0xa0, 0x8e, 0x29, 0x50, 0x71, 0x6f, 0xaf, 0x11, 0x50, 0xcc, 0x12, 0x09, 0x7d, 0x09, 0x0d, + 0x95, 0xb6, 0xa7, 0x60, 0xa8, 0x57, 0xa4, 0x7c, 0xab, 0x84, 0xf4, 0xb0, 0xef, 0x9c, 0xcc, 0x3c, + 0x31, 0x0d, 0x3d, 0x9e, 0x10, 0xe2, 0xe3, 0x69, 0x2c, 0x58, 0xea, 0xa1, 0x8f, 0xa1, 0xa1, 0x52, + 0xb7, 0xcd, 0xf8, 0x1e, 0x34, 0x73, 0x5b, 0x23, 0x14, 0x76, 0xe4, 0xd6, 0xde, 0xba, 0x62, 0x62, + 0xe9, 0x9d, 0xea, 0x9e, 0xc9, 0xb2, 0x9a, 0x58, 0x60, 0xa0, 0xe7, 0xd5, 0x18, 0x37, 0x63, 0xb2, + 0xb4, 0xa4, 0x7f, 0x2a, 0x50, 0x93, 0xb7, 0x4a, 0x7f, 0x55, 0xd2, 0x55, 0x1c, 0x40, 0x0d, 0x23, + 0x96, 0x5b, 0xa7, 0xbe, 0xb6, 0xce, 0xc2, 0xdb, 0x5f, 0xad, 0xf3, 0x00, 0x6a, 0x18, 0xaa, 0xed, + 0x9d, 0x5f, 0x75, 0x30, 0x57, 0x8f, 0x64, 0x6b, 0xff, 0xe6, 0x03, 0xca, 0x8d, 0x46, 0x98, 0xe8, + 0x6a, 0xe9, 0x46, 0x71, 0x20, 0x4b, 0x24, 0x94, 0x43, 0x33, 0x1f, 0xdf, 0xed, 0xff, 0xc6, 0x3d, + 0x68, 0xa9, 0xb9, 0xf1, 0x61, 0x14, 0xb9, 0x73, 0xab, 0x82, 0x17, 0x51, 0x6c, 0x76, 0x4d, 0x30, + 0x2e, 0x78, 0x1c, 0xbb, 0xe7, 0xbc, 0x7b, 0xfb, 0xfb, 0xc2, 0xd6, 0xaf, 0x16, 0xb6, 0xfe, 0x73, + 0x61, 0xeb, 0xdf, 0x96, 0xb6, 0x76, 0xb5, 0xb4, 0xb5, 0x1f, 0x4b, 0x5b, 0xfb, 0x50, 0x09, 0x87, + 0xc3, 0x06, 0x7e, 0x92, 0x1f, 0xfd, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x48, 0x94, 0x96, 0xc8, + 0x05, 0x00, 0x00, } func (m *Event) Marshal() (dAtA []byte, err error) { @@ -2572,7 +2573,7 @@ func (m *EventBlockUpdate) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Changes == nil { - m.Changes = &BlockChanges{} + m.Changes = &ChangeMultipleBlocksList{} } if err := m.Changes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err diff --git a/pb/models.pb.go b/pb/models.pb.go index 085dee844..a6a655593 100644 --- a/pb/models.pb.go +++ b/pb/models.pb.go @@ -23,22 +23,22 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -type ModelBlockHeaderType int32 +type ModelBlockType int32 const ( - ModelBlockHeader_DASHBOARD ModelBlockHeaderType = 0 - ModelBlockHeader_PAGE ModelBlockHeaderType = 1 - ModelBlockHeader_DATAVIEW ModelBlockHeaderType = 2 - ModelBlockHeader_TEXT ModelBlockHeaderType = 3 - ModelBlockHeader_FILE ModelBlockHeaderType = 4 - ModelBlockHeader_PICTURE ModelBlockHeaderType = 5 - ModelBlockHeader_VIDEO ModelBlockHeaderType = 6 - ModelBlockHeader_BOOKMARK ModelBlockHeaderType = 7 - ModelBlockHeader_LAYOUT ModelBlockHeaderType = 8 - ModelBlockHeader_DIV ModelBlockHeaderType = 9 + ModelBlock_DASHBOARD ModelBlockType = 0 + ModelBlock_PAGE ModelBlockType = 1 + ModelBlock_DATAVIEW ModelBlockType = 2 + ModelBlock_TEXT ModelBlockType = 3 + ModelBlock_FILE ModelBlockType = 4 + ModelBlock_PICTURE ModelBlockType = 5 + ModelBlock_VIDEO ModelBlockType = 6 + ModelBlock_BOOKMARK ModelBlockType = 7 + ModelBlock_LAYOUT ModelBlockType = 8 + ModelBlock_DIV ModelBlockType = 9 ) -var ModelBlockHeaderType_name = map[int32]string{ +var ModelBlockType_name = map[int32]string{ 0: "DASHBOARD", 1: "PAGE", 2: "DATAVIEW", @@ -51,7 +51,7 @@ var ModelBlockHeaderType_name = map[int32]string{ 9: "DIV", } -var ModelBlockHeaderType_value = map[string]int32{ +var ModelBlockType_value = map[string]int32{ "DASHBOARD": 0, "PAGE": 1, "DATAVIEW": 2, @@ -64,12 +64,12 @@ var ModelBlockHeaderType_value = map[string]int32{ "DIV": 9, } -func (x ModelBlockHeaderType) String() string { - return proto.EnumName(ModelBlockHeaderType_name, int32(x)) +func (x ModelBlockType) String() string { + return proto.EnumName(ModelBlockType_name, int32(x)) } -func (ModelBlockHeaderType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 0, 0} +func (ModelBlockType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 0} } type ModelBlockContentLayoutStyle int32 @@ -221,17 +221,17 @@ func (ModelBlockContentTextMarkType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 4, 1, 0} } -type ModelBlockContentMediaState int32 +type ModelBlockContentVideoState int32 const ( - ModelBlockContentMedia_EMPTY ModelBlockContentMediaState = 0 - ModelBlockContentMedia_UPLOADING ModelBlockContentMediaState = 1 - ModelBlockContentMedia_PREVIEW ModelBlockContentMediaState = 2 - ModelBlockContentMedia_DOWNLOADING ModelBlockContentMediaState = 3 - ModelBlockContentMedia_DONE ModelBlockContentMediaState = 4 + ModelBlockContentVideo_EMPTY ModelBlockContentVideoState = 0 + ModelBlockContentVideo_UPLOADING ModelBlockContentVideoState = 1 + ModelBlockContentVideo_PREVIEW ModelBlockContentVideoState = 2 + ModelBlockContentVideo_DOWNLOADING ModelBlockContentVideoState = 3 + ModelBlockContentVideo_DONE ModelBlockContentVideoState = 4 ) -var ModelBlockContentMediaState_name = map[int32]string{ +var ModelBlockContentVideoState_name = map[int32]string{ 0: "EMPTY", 1: "UPLOADING", 2: "PREVIEW", @@ -239,7 +239,7 @@ var ModelBlockContentMediaState_name = map[int32]string{ 4: "DONE", } -var ModelBlockContentMediaState_value = map[string]int32{ +var ModelBlockContentVideoState_value = map[string]int32{ "EMPTY": 0, "UPLOADING": 1, "PREVIEW": 2, @@ -247,14 +247,82 @@ var ModelBlockContentMediaState_value = map[string]int32{ "DONE": 4, } -func (x ModelBlockContentMediaState) String() string { - return proto.EnumName(ModelBlockContentMediaState_name, int32(x)) +func (x ModelBlockContentVideoState) String() string { + return proto.EnumName(ModelBlockContentVideoState_name, int32(x)) } -func (ModelBlockContentMediaState) EnumDescriptor() ([]byte, []int) { +func (ModelBlockContentVideoState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 5, 0} } +type ModelBlockContentImageState int32 + +const ( + ModelBlockContentImage_EMPTY ModelBlockContentImageState = 0 + ModelBlockContentImage_UPLOADING ModelBlockContentImageState = 1 + ModelBlockContentImage_PREVIEW ModelBlockContentImageState = 2 + ModelBlockContentImage_DOWNLOADING ModelBlockContentImageState = 3 + ModelBlockContentImage_DONE ModelBlockContentImageState = 4 +) + +var ModelBlockContentImageState_name = map[int32]string{ + 0: "EMPTY", + 1: "UPLOADING", + 2: "PREVIEW", + 3: "DOWNLOADING", + 4: "DONE", +} + +var ModelBlockContentImageState_value = map[string]int32{ + "EMPTY": 0, + "UPLOADING": 1, + "PREVIEW": 2, + "DOWNLOADING": 3, + "DONE": 4, +} + +func (x ModelBlockContentImageState) String() string { + return proto.EnumName(ModelBlockContentImageState_name, int32(x)) +} + +func (ModelBlockContentImageState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 6, 0} +} + +type ModelBlockContentFileState int32 + +const ( + ModelBlockContentFile_EMPTY ModelBlockContentFileState = 0 + ModelBlockContentFile_UPLOADING ModelBlockContentFileState = 1 + ModelBlockContentFile_PREVIEW ModelBlockContentFileState = 2 + ModelBlockContentFile_DOWNLOADING ModelBlockContentFileState = 3 + ModelBlockContentFile_DONE ModelBlockContentFileState = 4 +) + +var ModelBlockContentFileState_name = map[int32]string{ + 0: "EMPTY", + 1: "UPLOADING", + 2: "PREVIEW", + 3: "DOWNLOADING", + 4: "DONE", +} + +var ModelBlockContentFileState_value = map[string]int32{ + "EMPTY": 0, + "UPLOADING": 1, + "PREVIEW": 2, + "DOWNLOADING": 3, + "DONE": 4, +} + +func (x ModelBlockContentFileState) String() string { + return proto.EnumName(ModelBlockContentFileState_name, int32(x)) +} + +func (ModelBlockContentFileState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 7, 0} +} + type ModelBlockContentPageStyle int32 const ( @@ -283,7 +351,7 @@ func (x ModelBlockContentPageStyle) String() string { } func (ModelBlockContentPageStyle) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 6, 0} + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 8, 0} } // `NullValue` is a singleton enumeration to represent the null value for the @@ -411,14 +479,18 @@ func (m *Model) XXX_DiscardUnknown() { var xxx_messageInfo_Model proto.InternalMessageInfo type ModelBlock struct { - Header *ModelBlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - Children []string `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Fields *ModelStruct `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"` + Permissions *ModelBlockPermissions `protobuf:"bytes,3,opt,name=permissions,proto3" json:"permissions,omitempty"` + Children []string `protobuf:"bytes,4,rep,name=children,proto3" json:"children,omitempty"` // Types that are valid to be assigned to Content: // *ModelBlockContentOfDashboard // *ModelBlockContentOfPage // *ModelBlockContentOfDataview // *ModelBlockContentOfText - // *ModelBlockContentOfMedia + // *ModelBlockContentOfVideo + // *ModelBlockContentOfImage + // *ModelBlockContentOfFile // *ModelBlockContentOfLayout // *ModelBlockContentOfDiv Content isModelBlockContent `protobuf_oneof:"content"` @@ -475,21 +547,29 @@ type ModelBlockContentOfDataview struct { type ModelBlockContentOfText struct { Text *ModelBlockContentText `protobuf:"bytes,14,opt,name=text,proto3,oneof" json:"text,omitempty"` } -type ModelBlockContentOfMedia struct { - Media *ModelBlockContentMedia `protobuf:"bytes,15,opt,name=media,proto3,oneof" json:"media,omitempty"` +type ModelBlockContentOfVideo struct { + Video *ModelBlockContentVideo `protobuf:"bytes,15,opt,name=video,proto3,oneof" json:"video,omitempty"` +} +type ModelBlockContentOfImage struct { + Image *ModelBlockContentImage `protobuf:"bytes,16,opt,name=image,proto3,oneof" json:"image,omitempty"` +} +type ModelBlockContentOfFile struct { + File *ModelBlockContentFile `protobuf:"bytes,17,opt,name=file,proto3,oneof" json:"file,omitempty"` } type ModelBlockContentOfLayout struct { - Layout *ModelBlockContentLayout `protobuf:"bytes,16,opt,name=layout,proto3,oneof" json:"layout,omitempty"` + Layout *ModelBlockContentLayout `protobuf:"bytes,18,opt,name=layout,proto3,oneof" json:"layout,omitempty"` } type ModelBlockContentOfDiv struct { - Div *ModelBlockContentDiv `protobuf:"bytes,17,opt,name=div,proto3,oneof" json:"div,omitempty"` + Div *ModelBlockContentDiv `protobuf:"bytes,19,opt,name=div,proto3,oneof" json:"div,omitempty"` } func (*ModelBlockContentOfDashboard) isModelBlockContent() {} func (*ModelBlockContentOfPage) isModelBlockContent() {} func (*ModelBlockContentOfDataview) isModelBlockContent() {} func (*ModelBlockContentOfText) isModelBlockContent() {} -func (*ModelBlockContentOfMedia) isModelBlockContent() {} +func (*ModelBlockContentOfVideo) isModelBlockContent() {} +func (*ModelBlockContentOfImage) isModelBlockContent() {} +func (*ModelBlockContentOfFile) isModelBlockContent() {} func (*ModelBlockContentOfLayout) isModelBlockContent() {} func (*ModelBlockContentOfDiv) isModelBlockContent() {} @@ -500,9 +580,23 @@ func (m *ModelBlock) GetContent() isModelBlockContent { return nil } -func (m *ModelBlock) GetHeader() *ModelBlockHeader { +func (m *ModelBlock) GetId() string { if m != nil { - return m.Header + return m.Id + } + return "" +} + +func (m *ModelBlock) GetFields() *ModelStruct { + if m != nil { + return m.Fields + } + return nil +} + +func (m *ModelBlock) GetPermissions() *ModelBlockPermissions { + if m != nil { + return m.Permissions } return nil } @@ -542,9 +636,23 @@ func (m *ModelBlock) GetText() *ModelBlockContentText { return nil } -func (m *ModelBlock) GetMedia() *ModelBlockContentMedia { - if x, ok := m.GetContent().(*ModelBlockContentOfMedia); ok { - return x.Media +func (m *ModelBlock) GetVideo() *ModelBlockContentVideo { + if x, ok := m.GetContent().(*ModelBlockContentOfVideo); ok { + return x.Video + } + return nil +} + +func (m *ModelBlock) GetImage() *ModelBlockContentImage { + if x, ok := m.GetContent().(*ModelBlockContentOfImage); ok { + return x.Image + } + return nil +} + +func (m *ModelBlock) GetFile() *ModelBlockContentFile { + if x, ok := m.GetContent().(*ModelBlockContentOfFile); ok { + return x.File } return nil } @@ -570,81 +678,15 @@ func (*ModelBlock) XXX_OneofWrappers() []interface{} { (*ModelBlockContentOfPage)(nil), (*ModelBlockContentOfDataview)(nil), (*ModelBlockContentOfText)(nil), - (*ModelBlockContentOfMedia)(nil), + (*ModelBlockContentOfVideo)(nil), + (*ModelBlockContentOfImage)(nil), + (*ModelBlockContentOfFile)(nil), (*ModelBlockContentOfLayout)(nil), (*ModelBlockContentOfDiv)(nil), } } -type ModelBlockHeader struct { - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Type ModelBlockHeaderType `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.ModelBlockHeaderType" json:"type,omitempty"` - Fields *ModelStruct `protobuf:"bytes,3,opt,name=fields,proto3" json:"fields,omitempty"` - Permissions *ModelBlockHeaderPermissions `protobuf:"bytes,4,opt,name=permissions,proto3" json:"permissions,omitempty"` -} - -func (m *ModelBlockHeader) Reset() { *m = ModelBlockHeader{} } -func (m *ModelBlockHeader) String() string { return proto.CompactTextString(m) } -func (*ModelBlockHeader) ProtoMessage() {} -func (*ModelBlockHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 0} -} -func (m *ModelBlockHeader) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ModelBlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ModelBlockHeader.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *ModelBlockHeader) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModelBlockHeader.Merge(m, src) -} -func (m *ModelBlockHeader) XXX_Size() int { - return m.Size() -} -func (m *ModelBlockHeader) XXX_DiscardUnknown() { - xxx_messageInfo_ModelBlockHeader.DiscardUnknown(m) -} - -var xxx_messageInfo_ModelBlockHeader proto.InternalMessageInfo - -func (m *ModelBlockHeader) GetId() string { - if m != nil { - return m.Id - } - return "" -} - -func (m *ModelBlockHeader) GetType() ModelBlockHeaderType { - if m != nil { - return m.Type - } - return ModelBlockHeader_DASHBOARD -} - -func (m *ModelBlockHeader) GetFields() *ModelStruct { - if m != nil { - return m.Fields - } - return nil -} - -func (m *ModelBlockHeader) GetPermissions() *ModelBlockHeaderPermissions { - if m != nil { - return m.Permissions - } - return nil -} - -type ModelBlockHeaderPermissions struct { +type ModelBlockPermissions 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"` @@ -652,18 +694,18 @@ type ModelBlockHeaderPermissions struct { DropOn bool `protobuf:"varint,5,opt,name=dropOn,proto3" json:"dropOn,omitempty"` } -func (m *ModelBlockHeaderPermissions) Reset() { *m = ModelBlockHeaderPermissions{} } -func (m *ModelBlockHeaderPermissions) String() string { return proto.CompactTextString(m) } -func (*ModelBlockHeaderPermissions) ProtoMessage() {} -func (*ModelBlockHeaderPermissions) Descriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 0, 0} +func (m *ModelBlockPermissions) Reset() { *m = ModelBlockPermissions{} } +func (m *ModelBlockPermissions) String() string { return proto.CompactTextString(m) } +func (*ModelBlockPermissions) ProtoMessage() {} +func (*ModelBlockPermissions) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 0} } -func (m *ModelBlockHeaderPermissions) XXX_Unmarshal(b []byte) error { +func (m *ModelBlockPermissions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ModelBlockHeaderPermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ModelBlockPermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ModelBlockHeaderPermissions.Marshal(b, m, deterministic) + return xxx_messageInfo_ModelBlockPermissions.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -673,47 +715,47 @@ func (m *ModelBlockHeaderPermissions) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *ModelBlockHeaderPermissions) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModelBlockHeaderPermissions.Merge(m, src) +func (m *ModelBlockPermissions) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockPermissions.Merge(m, src) } -func (m *ModelBlockHeaderPermissions) XXX_Size() int { +func (m *ModelBlockPermissions) XXX_Size() int { return m.Size() } -func (m *ModelBlockHeaderPermissions) XXX_DiscardUnknown() { - xxx_messageInfo_ModelBlockHeaderPermissions.DiscardUnknown(m) +func (m *ModelBlockPermissions) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockPermissions.DiscardUnknown(m) } -var xxx_messageInfo_ModelBlockHeaderPermissions proto.InternalMessageInfo +var xxx_messageInfo_ModelBlockPermissions proto.InternalMessageInfo -func (m *ModelBlockHeaderPermissions) GetRead() bool { +func (m *ModelBlockPermissions) GetRead() bool { if m != nil { return m.Read } return false } -func (m *ModelBlockHeaderPermissions) GetEdit() bool { +func (m *ModelBlockPermissions) GetEdit() bool { if m != nil { return m.Edit } return false } -func (m *ModelBlockHeaderPermissions) GetRemove() bool { +func (m *ModelBlockPermissions) GetRemove() bool { if m != nil { return m.Remove } return false } -func (m *ModelBlockHeaderPermissions) GetDrag() bool { +func (m *ModelBlockPermissions) GetDrag() bool { if m != nil { return m.Drag } return false } -func (m *ModelBlockHeaderPermissions) GetDropOn() bool { +func (m *ModelBlockPermissions) GetDropOn() bool { if m != nil { return m.DropOn } @@ -837,8 +879,7 @@ func (m *ModelBlockContentDiv) XXX_DiscardUnknown() { var xxx_messageInfo_ModelBlockContentDiv proto.InternalMessageInfo type ModelBlockContentDashboard struct { - Style ModelBlockContentDashboardStyle `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.ModelBlockContentDashboardStyle" json:"style,omitempty"` - Headers []*ModelBlockHeader `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty"` + Style ModelBlockContentDashboardStyle `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.ModelBlockContentDashboardStyle" json:"style,omitempty"` } func (m *ModelBlockContentDashboard) Reset() { *m = ModelBlockContentDashboard{} } @@ -881,13 +922,6 @@ func (m *ModelBlockContentDashboard) GetStyle() ModelBlockContentDashboardStyle return ModelBlockContentDashboard_MAIN_SCREEN } -func (m *ModelBlockContentDashboard) GetHeaders() []*ModelBlockHeader { - if m != nil { - return m.Headers - } - return nil -} - type ModelBlockContentDataview struct { } @@ -1120,28 +1154,24 @@ func (m *ModelBlockContentTextMark) GetParam() string { return "" } -type ModelBlockContentMedia struct { - Content []byte `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` - State ModelBlockContentMediaState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentMediaState" json:"state,omitempty"` - // Types that are valid to be assigned to Preview: - // *ModelBlockContentMediaPreviewOfVideo - // *ModelBlockContentMediaPreviewOfImage - // *ModelBlockContentMediaPreviewOfFile - Preview isModelBlockContentMediaPreview `protobuf_oneof:"preview"` +type ModelBlockContentVideo struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + State ModelBlockContentVideoState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentVideoState" json:"state,omitempty"` + Preview *ModelBlockContentVideoPreview `protobuf:"bytes,3,opt,name=preview,proto3" json:"preview,omitempty"` } -func (m *ModelBlockContentMedia) Reset() { *m = ModelBlockContentMedia{} } -func (m *ModelBlockContentMedia) String() string { return proto.CompactTextString(m) } -func (*ModelBlockContentMedia) ProtoMessage() {} -func (*ModelBlockContentMedia) Descriptor() ([]byte, []int) { +func (m *ModelBlockContentVideo) Reset() { *m = ModelBlockContentVideo{} } +func (m *ModelBlockContentVideo) String() string { return proto.CompactTextString(m) } +func (*ModelBlockContentVideo) ProtoMessage() {} +func (*ModelBlockContentVideo) Descriptor() ([]byte, []int) { return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 5} } -func (m *ModelBlockContentMedia) XXX_Unmarshal(b []byte) error { +func (m *ModelBlockContentVideo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ModelBlockContentMedia) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ModelBlockContentVideo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ModelBlockContentMedia.Marshal(b, m, deterministic) + return xxx_messageInfo_ModelBlockContentVideo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1151,107 +1181,177 @@ func (m *ModelBlockContentMedia) XXX_Marshal(b []byte, deterministic bool) ([]by return b[:n], nil } } -func (m *ModelBlockContentMedia) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModelBlockContentMedia.Merge(m, src) +func (m *ModelBlockContentVideo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockContentVideo.Merge(m, src) } -func (m *ModelBlockContentMedia) XXX_Size() int { +func (m *ModelBlockContentVideo) XXX_Size() int { return m.Size() } -func (m *ModelBlockContentMedia) XXX_DiscardUnknown() { - xxx_messageInfo_ModelBlockContentMedia.DiscardUnknown(m) +func (m *ModelBlockContentVideo) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockContentVideo.DiscardUnknown(m) } -var xxx_messageInfo_ModelBlockContentMedia proto.InternalMessageInfo +var xxx_messageInfo_ModelBlockContentVideo proto.InternalMessageInfo -type isModelBlockContentMediaPreview interface { - isModelBlockContentMediaPreview() - MarshalTo([]byte) (int, error) - Size() int +func (m *ModelBlockContentVideo) GetContent() string { + if m != nil { + return m.Content + } + return "" } -type ModelBlockContentMediaPreviewOfVideo struct { - Video *ModelBlockContentMediaVideoPreview `protobuf:"bytes,101,opt,name=video,proto3,oneof" json:"video,omitempty"` -} -type ModelBlockContentMediaPreviewOfImage struct { - Image *ModelBlockContentMediaImagePreview `protobuf:"bytes,102,opt,name=image,proto3,oneof" json:"image,omitempty"` -} -type ModelBlockContentMediaPreviewOfFile struct { - File *ModelBlockContentMediaFilePreview `protobuf:"bytes,103,opt,name=file,proto3,oneof" json:"file,omitempty"` +func (m *ModelBlockContentVideo) GetState() ModelBlockContentVideoState { + if m != nil { + return m.State + } + return ModelBlockContentVideo_EMPTY } -func (*ModelBlockContentMediaPreviewOfVideo) isModelBlockContentMediaPreview() {} -func (*ModelBlockContentMediaPreviewOfImage) isModelBlockContentMediaPreview() {} -func (*ModelBlockContentMediaPreviewOfFile) isModelBlockContentMediaPreview() {} - -func (m *ModelBlockContentMedia) GetPreview() isModelBlockContentMediaPreview { +func (m *ModelBlockContentVideo) GetPreview() *ModelBlockContentVideoPreview { if m != nil { return m.Preview } return nil } -func (m *ModelBlockContentMedia) GetContent() []byte { +type ModelBlockContentVideoPreview struct { + Thumbnail []byte `protobuf:"bytes,1,opt,name=thumbnail,proto3" json:"thumbnail,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Width int32 `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"` +} + +func (m *ModelBlockContentVideoPreview) Reset() { *m = ModelBlockContentVideoPreview{} } +func (m *ModelBlockContentVideoPreview) String() string { return proto.CompactTextString(m) } +func (*ModelBlockContentVideoPreview) ProtoMessage() {} +func (*ModelBlockContentVideoPreview) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 5, 0} +} +func (m *ModelBlockContentVideoPreview) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ModelBlockContentVideoPreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ModelBlockContentVideoPreview.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ModelBlockContentVideoPreview) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockContentVideoPreview.Merge(m, src) +} +func (m *ModelBlockContentVideoPreview) XXX_Size() int { + return m.Size() +} +func (m *ModelBlockContentVideoPreview) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockContentVideoPreview.DiscardUnknown(m) +} + +var xxx_messageInfo_ModelBlockContentVideoPreview proto.InternalMessageInfo + +func (m *ModelBlockContentVideoPreview) GetThumbnail() []byte { + if m != nil { + return m.Thumbnail + } + return nil +} + +func (m *ModelBlockContentVideoPreview) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *ModelBlockContentVideoPreview) GetWidth() int32 { + if m != nil { + return m.Width + } + return 0 +} + +type ModelBlockContentImage struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + State ModelBlockContentImageState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentImageState" json:"state,omitempty"` + Preview *ModelBlockContentImagePreview `protobuf:"bytes,3,opt,name=preview,proto3" json:"preview,omitempty"` +} + +func (m *ModelBlockContentImage) Reset() { *m = ModelBlockContentImage{} } +func (m *ModelBlockContentImage) String() string { return proto.CompactTextString(m) } +func (*ModelBlockContentImage) ProtoMessage() {} +func (*ModelBlockContentImage) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 6} +} +func (m *ModelBlockContentImage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ModelBlockContentImage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ModelBlockContentImage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ModelBlockContentImage) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockContentImage.Merge(m, src) +} +func (m *ModelBlockContentImage) XXX_Size() int { + return m.Size() +} +func (m *ModelBlockContentImage) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockContentImage.DiscardUnknown(m) +} + +var xxx_messageInfo_ModelBlockContentImage proto.InternalMessageInfo + +func (m *ModelBlockContentImage) GetContent() string { if m != nil { return m.Content } - return nil + return "" } -func (m *ModelBlockContentMedia) GetState() ModelBlockContentMediaState { +func (m *ModelBlockContentImage) GetState() ModelBlockContentImageState { if m != nil { return m.State } - return ModelBlockContentMedia_EMPTY + return ModelBlockContentImage_EMPTY } -func (m *ModelBlockContentMedia) GetVideo() *ModelBlockContentMediaVideoPreview { - if x, ok := m.GetPreview().(*ModelBlockContentMediaPreviewOfVideo); ok { - return x.Video +func (m *ModelBlockContentImage) GetPreview() *ModelBlockContentImagePreview { + if m != nil { + return m.Preview } return nil } -func (m *ModelBlockContentMedia) GetImage() *ModelBlockContentMediaImagePreview { - if x, ok := m.GetPreview().(*ModelBlockContentMediaPreviewOfImage); ok { - return x.Image - } - return nil -} - -func (m *ModelBlockContentMedia) GetFile() *ModelBlockContentMediaFilePreview { - if x, ok := m.GetPreview().(*ModelBlockContentMediaPreviewOfFile); ok { - return x.File - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*ModelBlockContentMedia) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*ModelBlockContentMediaPreviewOfVideo)(nil), - (*ModelBlockContentMediaPreviewOfImage)(nil), - (*ModelBlockContentMediaPreviewOfFile)(nil), - } -} - -type ModelBlockContentMediaVideoPreview struct { +type ModelBlockContentImagePreview struct { Thumbnail []byte `protobuf:"bytes,1,opt,name=thumbnail,proto3" json:"thumbnail,omitempty"` Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` Width int32 `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"` } -func (m *ModelBlockContentMediaVideoPreview) Reset() { *m = ModelBlockContentMediaVideoPreview{} } -func (m *ModelBlockContentMediaVideoPreview) String() string { return proto.CompactTextString(m) } -func (*ModelBlockContentMediaVideoPreview) ProtoMessage() {} -func (*ModelBlockContentMediaVideoPreview) Descriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 5, 0} +func (m *ModelBlockContentImagePreview) Reset() { *m = ModelBlockContentImagePreview{} } +func (m *ModelBlockContentImagePreview) String() string { return proto.CompactTextString(m) } +func (*ModelBlockContentImagePreview) ProtoMessage() {} +func (*ModelBlockContentImagePreview) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 6, 0} } -func (m *ModelBlockContentMediaVideoPreview) XXX_Unmarshal(b []byte) error { +func (m *ModelBlockContentImagePreview) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ModelBlockContentMediaVideoPreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ModelBlockContentImagePreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ModelBlockContentMediaVideoPreview.Marshal(b, m, deterministic) + return xxx_messageInfo_ModelBlockContentImagePreview.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1261,57 +1361,57 @@ func (m *ModelBlockContentMediaVideoPreview) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *ModelBlockContentMediaVideoPreview) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModelBlockContentMediaVideoPreview.Merge(m, src) +func (m *ModelBlockContentImagePreview) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockContentImagePreview.Merge(m, src) } -func (m *ModelBlockContentMediaVideoPreview) XXX_Size() int { +func (m *ModelBlockContentImagePreview) XXX_Size() int { return m.Size() } -func (m *ModelBlockContentMediaVideoPreview) XXX_DiscardUnknown() { - xxx_messageInfo_ModelBlockContentMediaVideoPreview.DiscardUnknown(m) +func (m *ModelBlockContentImagePreview) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockContentImagePreview.DiscardUnknown(m) } -var xxx_messageInfo_ModelBlockContentMediaVideoPreview proto.InternalMessageInfo +var xxx_messageInfo_ModelBlockContentImagePreview proto.InternalMessageInfo -func (m *ModelBlockContentMediaVideoPreview) GetThumbnail() []byte { +func (m *ModelBlockContentImagePreview) GetThumbnail() []byte { if m != nil { return m.Thumbnail } return nil } -func (m *ModelBlockContentMediaVideoPreview) GetName() string { +func (m *ModelBlockContentImagePreview) GetName() string { if m != nil { return m.Name } return "" } -func (m *ModelBlockContentMediaVideoPreview) GetWidth() int32 { +func (m *ModelBlockContentImagePreview) GetWidth() int32 { if m != nil { return m.Width } return 0 } -type ModelBlockContentMediaImagePreview struct { - Thumbnail []byte `protobuf:"bytes,1,opt,name=thumbnail,proto3" json:"thumbnail,omitempty"` - Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` - Width int32 `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"` +type ModelBlockContentFile struct { + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + State ModelBlockContentFileState `protobuf:"varint,2,opt,name=state,proto3,enum=anytype.ModelBlockContentFileState" json:"state,omitempty"` + Preview *ModelBlockContentFilePreview `protobuf:"bytes,3,opt,name=preview,proto3" json:"preview,omitempty"` } -func (m *ModelBlockContentMediaImagePreview) Reset() { *m = ModelBlockContentMediaImagePreview{} } -func (m *ModelBlockContentMediaImagePreview) String() string { return proto.CompactTextString(m) } -func (*ModelBlockContentMediaImagePreview) ProtoMessage() {} -func (*ModelBlockContentMediaImagePreview) Descriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 5, 1} +func (m *ModelBlockContentFile) Reset() { *m = ModelBlockContentFile{} } +func (m *ModelBlockContentFile) String() string { return proto.CompactTextString(m) } +func (*ModelBlockContentFile) ProtoMessage() {} +func (*ModelBlockContentFile) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 7} } -func (m *ModelBlockContentMediaImagePreview) XXX_Unmarshal(b []byte) error { +func (m *ModelBlockContentFile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ModelBlockContentMediaImagePreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ModelBlockContentFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ModelBlockContentMediaImagePreview.Marshal(b, m, deterministic) + return xxx_messageInfo_ModelBlockContentFile.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1321,56 +1421,56 @@ func (m *ModelBlockContentMediaImagePreview) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *ModelBlockContentMediaImagePreview) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModelBlockContentMediaImagePreview.Merge(m, src) +func (m *ModelBlockContentFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockContentFile.Merge(m, src) } -func (m *ModelBlockContentMediaImagePreview) XXX_Size() int { +func (m *ModelBlockContentFile) XXX_Size() int { return m.Size() } -func (m *ModelBlockContentMediaImagePreview) XXX_DiscardUnknown() { - xxx_messageInfo_ModelBlockContentMediaImagePreview.DiscardUnknown(m) +func (m *ModelBlockContentFile) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockContentFile.DiscardUnknown(m) } -var xxx_messageInfo_ModelBlockContentMediaImagePreview proto.InternalMessageInfo +var xxx_messageInfo_ModelBlockContentFile proto.InternalMessageInfo -func (m *ModelBlockContentMediaImagePreview) GetThumbnail() []byte { +func (m *ModelBlockContentFile) GetContent() string { if m != nil { - return m.Thumbnail - } - return nil -} - -func (m *ModelBlockContentMediaImagePreview) GetName() string { - if m != nil { - return m.Name + return m.Content } return "" } -func (m *ModelBlockContentMediaImagePreview) GetWidth() int32 { +func (m *ModelBlockContentFile) GetState() ModelBlockContentFileState { if m != nil { - return m.Width + return m.State } - return 0 + return ModelBlockContentFile_EMPTY } -type ModelBlockContentMediaFilePreview struct { +func (m *ModelBlockContentFile) GetPreview() *ModelBlockContentFilePreview { + if m != nil { + return m.Preview + } + return nil +} + +type ModelBlockContentFilePreview struct { Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Icon string `protobuf:"bytes,2,opt,name=icon,proto3" json:"icon,omitempty"` } -func (m *ModelBlockContentMediaFilePreview) Reset() { *m = ModelBlockContentMediaFilePreview{} } -func (m *ModelBlockContentMediaFilePreview) String() string { return proto.CompactTextString(m) } -func (*ModelBlockContentMediaFilePreview) ProtoMessage() {} -func (*ModelBlockContentMediaFilePreview) Descriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 5, 2} +func (m *ModelBlockContentFilePreview) Reset() { *m = ModelBlockContentFilePreview{} } +func (m *ModelBlockContentFilePreview) String() string { return proto.CompactTextString(m) } +func (*ModelBlockContentFilePreview) ProtoMessage() {} +func (*ModelBlockContentFilePreview) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 7, 0} } -func (m *ModelBlockContentMediaFilePreview) XXX_Unmarshal(b []byte) error { +func (m *ModelBlockContentFilePreview) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ModelBlockContentMediaFilePreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ModelBlockContentFilePreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ModelBlockContentMediaFilePreview.Marshal(b, m, deterministic) + return xxx_messageInfo_ModelBlockContentFilePreview.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1380,26 +1480,26 @@ func (m *ModelBlockContentMediaFilePreview) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *ModelBlockContentMediaFilePreview) XXX_Merge(src proto.Message) { - xxx_messageInfo_ModelBlockContentMediaFilePreview.Merge(m, src) +func (m *ModelBlockContentFilePreview) XXX_Merge(src proto.Message) { + xxx_messageInfo_ModelBlockContentFilePreview.Merge(m, src) } -func (m *ModelBlockContentMediaFilePreview) XXX_Size() int { +func (m *ModelBlockContentFilePreview) XXX_Size() int { return m.Size() } -func (m *ModelBlockContentMediaFilePreview) XXX_DiscardUnknown() { - xxx_messageInfo_ModelBlockContentMediaFilePreview.DiscardUnknown(m) +func (m *ModelBlockContentFilePreview) XXX_DiscardUnknown() { + xxx_messageInfo_ModelBlockContentFilePreview.DiscardUnknown(m) } -var xxx_messageInfo_ModelBlockContentMediaFilePreview proto.InternalMessageInfo +var xxx_messageInfo_ModelBlockContentFilePreview proto.InternalMessageInfo -func (m *ModelBlockContentMediaFilePreview) GetName() string { +func (m *ModelBlockContentFilePreview) GetName() string { if m != nil { return m.Name } return "" } -func (m *ModelBlockContentMediaFilePreview) GetIcon() string { +func (m *ModelBlockContentFilePreview) GetIcon() string { if m != nil { return m.Icon } @@ -1414,7 +1514,7 @@ func (m *ModelBlockContentPage) Reset() { *m = ModelBlockContentPage{} } func (m *ModelBlockContentPage) String() string { return proto.CompactTextString(m) } func (*ModelBlockContentPage) ProtoMessage() {} func (*ModelBlockContentPage) Descriptor() ([]byte, []int) { - return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 6} + return fileDescriptor_0b5431a010549573, []int{0, 0, 1, 8} } func (m *ModelBlockContentPage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1987,21 +2087,22 @@ func (m *ModelVideo) GetSizes() []ModelVideoSize { } func init() { - proto.RegisterEnum("anytype.ModelBlockHeaderType", ModelBlockHeaderType_name, ModelBlockHeaderType_value) + proto.RegisterEnum("anytype.ModelBlockType", ModelBlockType_name, ModelBlockType_value) proto.RegisterEnum("anytype.ModelBlockContentLayoutStyle", ModelBlockContentLayoutStyle_name, ModelBlockContentLayoutStyle_value) proto.RegisterEnum("anytype.ModelBlockContentDashboardStyle", ModelBlockContentDashboardStyle_name, ModelBlockContentDashboardStyle_value) proto.RegisterEnum("anytype.ModelBlockContentTextStyle", ModelBlockContentTextStyle_name, ModelBlockContentTextStyle_value) proto.RegisterEnum("anytype.ModelBlockContentTextMarkerType", ModelBlockContentTextMarkerType_name, ModelBlockContentTextMarkerType_value) proto.RegisterEnum("anytype.ModelBlockContentTextMarkType", ModelBlockContentTextMarkType_name, ModelBlockContentTextMarkType_value) - proto.RegisterEnum("anytype.ModelBlockContentMediaState", ModelBlockContentMediaState_name, ModelBlockContentMediaState_value) + proto.RegisterEnum("anytype.ModelBlockContentVideoState", ModelBlockContentVideoState_name, ModelBlockContentVideoState_value) + proto.RegisterEnum("anytype.ModelBlockContentImageState", ModelBlockContentImageState_name, ModelBlockContentImageState_value) + proto.RegisterEnum("anytype.ModelBlockContentFileState", ModelBlockContentFileState_name, ModelBlockContentFileState_value) proto.RegisterEnum("anytype.ModelBlockContentPageStyle", ModelBlockContentPageStyle_name, ModelBlockContentPageStyle_value) proto.RegisterEnum("anytype.ModelStructNullValue", ModelStructNullValue_name, ModelStructNullValue_value) proto.RegisterEnum("anytype.ModelImageSize", ModelImageSize_name, ModelImageSize_value) proto.RegisterEnum("anytype.ModelVideoSize", ModelVideoSize_name, ModelVideoSize_value) proto.RegisterType((*Model)(nil), "anytype.Model") proto.RegisterType((*ModelBlock)(nil), "anytype.Model.Block") - proto.RegisterType((*ModelBlockHeader)(nil), "anytype.Model.Block.Header") - proto.RegisterType((*ModelBlockHeaderPermissions)(nil), "anytype.Model.Block.Header.Permissions") + proto.RegisterType((*ModelBlockPermissions)(nil), "anytype.Model.Block.Permissions") proto.RegisterType((*ModelBlockContent)(nil), "anytype.Model.Block.Content") proto.RegisterType((*ModelBlockContentLayout)(nil), "anytype.Model.Block.Content.Layout") proto.RegisterType((*ModelBlockContentDiv)(nil), "anytype.Model.Block.Content.Div") @@ -2010,10 +2111,12 @@ func init() { proto.RegisterType((*ModelBlockContentText)(nil), "anytype.Model.Block.Content.Text") proto.RegisterType((*ModelBlockContentTextMarks)(nil), "anytype.Model.Block.Content.Text.Marks") proto.RegisterType((*ModelBlockContentTextMark)(nil), "anytype.Model.Block.Content.Text.Mark") - proto.RegisterType((*ModelBlockContentMedia)(nil), "anytype.Model.Block.Content.Media") - proto.RegisterType((*ModelBlockContentMediaVideoPreview)(nil), "anytype.Model.Block.Content.Media.VideoPreview") - proto.RegisterType((*ModelBlockContentMediaImagePreview)(nil), "anytype.Model.Block.Content.Media.ImagePreview") - proto.RegisterType((*ModelBlockContentMediaFilePreview)(nil), "anytype.Model.Block.Content.Media.FilePreview") + proto.RegisterType((*ModelBlockContentVideo)(nil), "anytype.Model.Block.Content.Video") + proto.RegisterType((*ModelBlockContentVideoPreview)(nil), "anytype.Model.Block.Content.Video.Preview") + proto.RegisterType((*ModelBlockContentImage)(nil), "anytype.Model.Block.Content.Image") + proto.RegisterType((*ModelBlockContentImagePreview)(nil), "anytype.Model.Block.Content.Image.Preview") + proto.RegisterType((*ModelBlockContentFile)(nil), "anytype.Model.Block.Content.File") + proto.RegisterType((*ModelBlockContentFilePreview)(nil), "anytype.Model.Block.Content.File.Preview") proto.RegisterType((*ModelBlockContentPage)(nil), "anytype.Model.Block.Content.Page") proto.RegisterType((*ModelRange)(nil), "anytype.Model.Range") proto.RegisterType((*ModelStruct)(nil), "anytype.Model.Struct") @@ -2029,112 +2132,111 @@ func init() { func init() { proto.RegisterFile("models.proto", fileDescriptor_0b5431a010549573) } var fileDescriptor_0b5431a010549573 = []byte{ - // 1675 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0x1b, 0xc7, - 0x15, 0xdf, 0x25, 0x77, 0xf9, 0xe7, 0x51, 0x96, 0x27, 0x83, 0x24, 0xd8, 0x6e, 0x5c, 0xc5, 0x61, - 0xd0, 0xd8, 0x6d, 0x52, 0x46, 0x96, 0xe4, 0x26, 0x35, 0x9a, 0x26, 0xa4, 0xb8, 0x16, 0x09, 0x51, - 0xa2, 0x30, 0xa4, 0xe4, 0xb8, 0x17, 0x61, 0xc5, 0x1d, 0x53, 0x0b, 0x2d, 0x77, 0x99, 0xe5, 0x52, - 0x89, 0x8c, 0x7e, 0x88, 0x7e, 0x80, 0x1e, 0x0a, 0xf4, 0x43, 0x14, 0xe8, 0xa1, 0x40, 0x6f, 0x3d, - 0xa6, 0xbd, 0xb4, 0xc7, 0xc2, 0xfe, 0x0e, 0xed, 0xb5, 0x78, 0x6f, 0x76, 0x49, 0xca, 0x96, 0x25, - 0x16, 0xc8, 0x89, 0xf3, 0x66, 0x7f, 0xbf, 0xf7, 0xde, 0xcc, 0xfb, 0x37, 0x84, 0x95, 0x51, 0xe4, - 0xc9, 0x60, 0x52, 0x1b, 0xc7, 0x51, 0x12, 0xf1, 0xa2, 0x1b, 0x5e, 0x24, 0x17, 0x63, 0x59, 0xfd, - 0xfd, 0x1a, 0x98, 0x7b, 0xf8, 0xc5, 0xfe, 0xfb, 0x3b, 0x60, 0x36, 0x82, 0x68, 0x70, 0xc6, 0x37, - 0xa1, 0x70, 0x2a, 0x5d, 0x4f, 0xc6, 0x96, 0x7e, 0x57, 0xbf, 0x5f, 0xd9, 0x78, 0xaf, 0x96, 0xa2, - 0x6b, 0x84, 0xac, 0x11, 0xaa, 0xd6, 0x22, 0x88, 0x48, 0xa1, 0xdc, 0x86, 0xd2, 0xe0, 0xd4, 0x0f, - 0xbc, 0x58, 0x86, 0x56, 0xee, 0x6e, 0xfe, 0x7e, 0x59, 0xcc, 0x64, 0xfe, 0x18, 0xca, 0x9e, 0x3b, - 0x39, 0x3d, 0x89, 0xdc, 0xd8, 0xb3, 0x2a, 0xa4, 0xf3, 0xa3, 0x2b, 0x75, 0x6e, 0x47, 0x61, 0x22, - 0xc3, 0xa4, 0xd6, 0xcc, 0xd0, 0x2d, 0x4d, 0xcc, 0xa9, 0xfc, 0x33, 0x30, 0xc6, 0xee, 0x50, 0x5a, - 0x2b, 0xa4, 0xe2, 0x83, 0x6b, 0x55, 0x1c, 0xb8, 0x43, 0xd9, 0xd2, 0x04, 0x11, 0xf8, 0x36, 0x94, - 0x3c, 0x37, 0x71, 0xcf, 0x7d, 0xf9, 0xad, 0x75, 0x8b, 0xc8, 0x3f, 0xb9, 0xc1, 0xbe, 0x02, 0xb7, - 0x34, 0x31, 0x23, 0xa2, 0xf5, 0x44, 0x7e, 0x97, 0x58, 0xab, 0x4b, 0x58, 0xef, 0xcb, 0xef, 0x12, - 0xb4, 0x8e, 0x04, 0xfe, 0x08, 0xcc, 0x91, 0xf4, 0x7c, 0xd7, 0xba, 0x4d, 0xcc, 0xea, 0xb5, 0xcc, - 0x3d, 0x44, 0xb6, 0x34, 0xa1, 0x28, 0xfc, 0x0b, 0x28, 0x04, 0xee, 0x45, 0x34, 0x4d, 0x2c, 0x46, - 0xe4, 0x0f, 0xaf, 0x25, 0x77, 0x08, 0xda, 0xd2, 0x44, 0x4a, 0xe2, 0x5b, 0x90, 0xf7, 0xfc, 0x73, - 0xeb, 0x2d, 0xe2, 0xde, 0xbd, 0xfe, 0xcc, 0xfe, 0x79, 0x4b, 0x13, 0x08, 0xb7, 0xff, 0x9a, 0x87, - 0x82, 0x0a, 0x2f, 0x5f, 0x85, 0x9c, 0xef, 0x51, 0x1e, 0x94, 0x45, 0xce, 0xf7, 0xf8, 0x16, 0x18, - 0xa8, 0xc1, 0xca, 0xdd, 0xd5, 0xef, 0xaf, 0xbe, 0x41, 0xa3, 0xa2, 0xd6, 0xfa, 0x17, 0x63, 0x29, - 0x08, 0xcd, 0x7f, 0x0e, 0x85, 0x67, 0xbe, 0x0c, 0xbc, 0x89, 0x95, 0x27, 0x4f, 0xde, 0x79, 0x85, - 0xd7, 0x4b, 0xe2, 0xe9, 0x20, 0x11, 0x29, 0x88, 0xb7, 0xa1, 0x32, 0x96, 0xf1, 0xc8, 0x9f, 0x4c, - 0xfc, 0x28, 0x9c, 0x58, 0x06, 0x71, 0xee, 0x5d, 0x67, 0xeb, 0x60, 0x0e, 0x17, 0x8b, 0x5c, 0xfb, - 0x02, 0x2a, 0x0b, 0xdf, 0x38, 0x07, 0x23, 0x96, 0xae, 0x3a, 0x50, 0x49, 0xd0, 0x1a, 0xf7, 0xa4, - 0xe7, 0x27, 0x74, 0xa4, 0x92, 0xa0, 0x35, 0x7f, 0x17, 0x0a, 0xb1, 0x1c, 0x45, 0xe7, 0x92, 0x1c, - 0x2e, 0x89, 0x54, 0x42, 0xac, 0x17, 0xbb, 0x43, 0x72, 0xa9, 0x24, 0x68, 0x8d, 0x58, 0x2f, 0x8e, - 0xc6, 0xdd, 0xd0, 0x32, 0x15, 0x56, 0x49, 0xd5, 0xdf, 0x82, 0x81, 0x57, 0xc0, 0x6f, 0x41, 0xb9, - 0x59, 0xef, 0xb5, 0x1a, 0xdd, 0xba, 0x68, 0x32, 0x8d, 0x97, 0xc0, 0x38, 0xa8, 0xef, 0x38, 0x4c, - 0xe7, 0x2b, 0x50, 0x6a, 0xd6, 0xfb, 0xf5, 0xa3, 0xb6, 0xf3, 0x84, 0xe5, 0x70, 0xbf, 0xef, 0x7c, - 0xdd, 0x67, 0x79, 0x5c, 0x3d, 0x6e, 0x77, 0x1c, 0x66, 0xf0, 0x0a, 0x14, 0x0f, 0xda, 0xdb, 0xfd, - 0x43, 0xe1, 0x30, 0x93, 0x97, 0xc1, 0x3c, 0x6a, 0x37, 0x9d, 0x2e, 0x2b, 0x20, 0xb3, 0xd1, 0xed, - 0xee, 0xee, 0xd5, 0xc5, 0x2e, 0x2b, 0x72, 0x80, 0x42, 0xa7, 0xfe, 0xb4, 0x7b, 0xd8, 0x67, 0x25, - 0x5e, 0x84, 0x7c, 0xb3, 0x7d, 0xc4, 0xca, 0xf6, 0x7f, 0x6f, 0x41, 0x31, 0x0d, 0xad, 0x3d, 0x84, - 0x82, 0xca, 0x0c, 0xfe, 0x25, 0x98, 0x93, 0xe4, 0x22, 0x90, 0x74, 0x01, 0xab, 0x1b, 0x3f, 0x5d, - 0x22, 0x9b, 0x6a, 0x3d, 0x24, 0x08, 0xc5, 0xab, 0xde, 0x01, 0x93, 0x64, 0x34, 0x24, 0xba, 0x4f, - 0x98, 0x86, 0xd6, 0xb7, 0xbb, 0x9d, 0xc3, 0xbd, 0x7d, 0xa6, 0xdb, 0x26, 0xe4, 0x9b, 0xfe, 0xb9, - 0xfd, 0x07, 0x1d, 0xca, 0xb3, 0x12, 0xe6, 0x8d, 0xcb, 0x36, 0x3f, 0x59, 0xae, 0xf2, 0x2f, 0x99, - 0xe5, 0x0f, 0xa1, 0xa8, 0xfa, 0xcc, 0x84, 0x9a, 0xcb, 0x0d, 0x3d, 0x29, 0xc3, 0x56, 0xad, 0xcc, - 0xdb, 0xdb, 0x50, 0xd9, 0xab, 0xb7, 0xf7, 0x8f, 0x7b, 0xdb, 0xc2, 0x71, 0xf6, 0x99, 0x66, 0x03, - 0x94, 0xb2, 0x22, 0xb7, 0xff, 0x69, 0x82, 0x81, 0x05, 0x8b, 0xd1, 0xa5, 0x0a, 0x57, 0xe9, 0xae, - 0x8a, 0xf7, 0x8b, 0xcc, 0x7b, 0x95, 0xf1, 0xf7, 0x6e, 0x2c, 0xfb, 0xcb, 0x8e, 0x3b, 0x50, 0x1e, - 0xb9, 0xf1, 0xd9, 0xa4, 0xe3, 0x4f, 0x92, 0x34, 0xf9, 0x97, 0x50, 0xb1, 0x87, 0x14, 0x31, 0x67, - 0xf2, 0x35, 0x80, 0x24, 0x1a, 0x0e, 0x03, 0xe9, 0x9e, 0x04, 0x32, 0xcd, 0xbe, 0x85, 0x1d, 0xde, - 0x01, 0x40, 0xb0, 0x8c, 0x31, 0xe3, 0x28, 0x0f, 0x6f, 0xba, 0xe8, 0x99, 0x1d, 0xc5, 0x11, 0x0b, - 0x7c, 0x7e, 0x07, 0xca, 0x83, 0x53, 0x39, 0x38, 0x23, 0x63, 0x05, 0x32, 0x36, 0xdf, 0xe0, 0x16, - 0x14, 0x49, 0x90, 0x9e, 0x55, 0xa4, 0x6f, 0x99, 0x68, 0x3b, 0x60, 0x92, 0xe7, 0xfc, 0x57, 0x60, - 0x92, 0xef, 0x96, 0x4e, 0xc1, 0xfa, 0x68, 0x39, 0x4f, 0x84, 0x22, 0xd9, 0xff, 0xd0, 0xc1, 0x40, - 0x99, 0xff, 0x0c, 0xcc, 0xd8, 0x0d, 0x87, 0x32, 0x9d, 0x43, 0x6f, 0xbf, 0xa2, 0x46, 0xe0, 0x37, - 0xa1, 0x20, 0xfc, 0xcb, 0x4b, 0x8d, 0xe9, 0xe3, 0xe5, 0x2c, 0x2e, 0xf6, 0xa8, 0xb7, 0xc1, 0x1c, - 0xbb, 0xb1, 0x3b, 0xa2, 0x28, 0x95, 0x85, 0x12, 0xaa, 0x3b, 0x69, 0x11, 0xbf, 0x05, 0xb7, 0x7a, - 0x7d, 0xd1, 0xde, 0x75, 0xfa, 0x2d, 0xd1, 0x3d, 0xdc, 0x69, 0x31, 0x0d, 0x8b, 0x70, 0xd7, 0x79, - 0xaa, 0xca, 0x5a, 0xc7, 0x32, 0x68, 0xf7, 0xeb, 0x9d, 0xf6, 0xb6, 0x2a, 0xe5, 0x46, 0xb7, 0xd3, - 0x54, 0xa5, 0xdc, 0x69, 0xef, 0xef, 0x32, 0xa3, 0xba, 0x9d, 0xa5, 0xa2, 0x09, 0xfa, 0x98, 0x69, - 0xbc, 0x00, 0xb9, 0xd3, 0x07, 0x4c, 0xa7, 0xdf, 0x0d, 0x96, 0xa3, 0xdf, 0x4d, 0x96, 0xa7, 0xdf, - 0x2d, 0x66, 0x60, 0xb5, 0x7f, 0x33, 0x8d, 0x12, 0xc9, 0x4c, 0x54, 0x32, 0x88, 0x3c, 0xc9, 0x0a, - 0xd5, 0x1a, 0xc0, 0x3c, 0x64, 0xb8, 0x1f, 0x46, 0xa1, 0x54, 0x35, 0x18, 0x4e, 0x47, 0x27, 0x32, - 0x56, 0x8e, 0x9c, 0x4c, 0x83, 0x40, 0x26, 0x2c, 0x67, 0xff, 0xc7, 0x00, 0x93, 0x06, 0x0a, 0x05, - 0x4d, 0x9d, 0x9e, 0x2e, 0x73, 0x45, 0x64, 0x22, 0xff, 0x35, 0x26, 0xb8, 0x9b, 0x64, 0x37, 0x77, - 0xff, 0xe6, 0xe9, 0x54, 0xeb, 0x21, 0x5e, 0x28, 0x1a, 0xdf, 0x01, 0xf3, 0xdc, 0xf7, 0x64, 0x64, - 0x49, 0x0a, 0xd2, 0xa7, 0x4b, 0xf0, 0x8f, 0x10, 0x7f, 0x10, 0xcb, 0x74, 0xc4, 0x2a, 0x3e, 0x2a, - 0xf2, 0x47, 0x38, 0xde, 0x9f, 0x2d, 0xad, 0xa8, 0x8d, 0xf8, 0x05, 0x45, 0xc4, 0xe7, 0x4d, 0x30, - 0x9e, 0xf9, 0x81, 0xb4, 0x86, 0xa4, 0xa7, 0xb6, 0x84, 0x9e, 0xc7, 0x7e, 0xb0, 0xa0, 0x86, 0xd8, - 0xf6, 0x11, 0xac, 0x2c, 0xfa, 0x89, 0x45, 0x91, 0x9c, 0x4e, 0x47, 0x27, 0xa1, 0xeb, 0x07, 0xe9, - 0x1d, 0xce, 0x37, 0xb0, 0x75, 0x84, 0xee, 0x48, 0x5d, 0x62, 0x59, 0xd0, 0x1a, 0x33, 0xea, 0x5b, - 0xdf, 0x4b, 0x4e, 0x29, 0xa3, 0x4c, 0xa1, 0x04, 0xd4, 0xbb, 0xe8, 0xf6, 0x0f, 0xa6, 0xf7, 0x21, - 0x54, 0x16, 0x8e, 0x31, 0x23, 0xea, 0x0b, 0x44, 0x0e, 0x86, 0x3f, 0x88, 0xc2, 0x4c, 0x19, 0xae, - 0xab, 0x6d, 0xcc, 0x4b, 0x8c, 0x63, 0x19, 0x4c, 0x67, 0xef, 0xa0, 0xff, 0x94, 0x69, 0x38, 0xb1, - 0x0e, 0x0f, 0x3a, 0xdd, 0x7a, 0xb3, 0xbd, 0xbf, 0xc3, 0x74, 0x9a, 0x42, 0xc2, 0x49, 0xc7, 0xd4, - 0x6d, 0xa8, 0x34, 0xbb, 0x4f, 0xf6, 0xb3, 0xaf, 0x94, 0xe2, 0xcd, 0xee, 0xbe, 0xc3, 0x8c, 0x46, - 0x19, 0x8a, 0x63, 0x65, 0xdd, 0x7e, 0x0e, 0x06, 0x3e, 0xc0, 0xe6, 0xdd, 0x53, 0x5f, 0xa2, 0x7b, - 0x22, 0xe3, 0xf2, 0xb4, 0xd9, 0xcc, 0x8a, 0x66, 0xc1, 0x39, 0x9c, 0x93, 0xf5, 0xde, 0xae, 0x9a, - 0x9f, 0xb3, 0x29, 0x98, 0xc3, 0x81, 0xd4, 0x73, 0xfa, 0x2c, 0x8f, 0x6e, 0xa4, 0xb9, 0x6d, 0x7f, - 0x0c, 0x26, 0x35, 0x09, 0x3c, 0xf9, 0xb3, 0x38, 0x1a, 0x91, 0x1b, 0xa6, 0xa0, 0x35, 0x3e, 0x6d, - 0x92, 0x88, 0xee, 0xc2, 0x14, 0xb9, 0x24, 0xb2, 0xff, 0x64, 0x40, 0x41, 0x3d, 0x44, 0xf8, 0x2f, - 0x67, 0xef, 0x15, 0xd5, 0xc0, 0x3e, 0xb8, 0xf2, 0xbd, 0x52, 0x7b, 0x4c, 0x18, 0x27, 0x4c, 0xe2, - 0x8b, 0xec, 0xed, 0x62, 0x1f, 0x61, 0x18, 0x66, 0xdb, 0x9c, 0x41, 0xfe, 0x4c, 0x5e, 0xa4, 0x51, - 0xc0, 0x25, 0x7f, 0x00, 0xe6, 0xb9, 0x1b, 0x4c, 0x55, 0x48, 0x5f, 0x1f, 0x64, 0xa9, 0xea, 0x23, - 0x84, 0x08, 0x85, 0x7c, 0x94, 0xfb, 0x5c, 0xb7, 0xff, 0x9c, 0x03, 0x93, 0x36, 0xf9, 0x57, 0x00, - 0xe1, 0x34, 0x08, 0x8e, 0x95, 0x16, 0x75, 0xb1, 0xef, 0x5f, 0xad, 0x65, 0x7f, 0x1a, 0x04, 0x44, - 0xc2, 0x77, 0x74, 0x98, 0x09, 0xfc, 0x43, 0x58, 0x51, 0xed, 0xe2, 0x78, 0xee, 0x89, 0xde, 0xd2, - 0x44, 0x45, 0xed, 0xce, 0x40, 0x93, 0x24, 0xf6, 0xc3, 0x61, 0x0a, 0xa2, 0xb6, 0x88, 0x20, 0xb5, - 0xab, 0x40, 0xef, 0x03, 0x9c, 0x44, 0x51, 0xe6, 0x0b, 0xcd, 0x25, 0x34, 0x85, 0x7b, 0x0a, 0xf0, - 0x88, 0xb4, 0x4c, 0x07, 0x49, 0x0a, 0x31, 0xaf, 0x79, 0xff, 0xa5, 0xca, 0xa7, 0x83, 0x64, 0x76, - 0xd0, 0xc0, 0x9f, 0x64, 0xcc, 0x02, 0x31, 0xdf, 0x70, 0x50, 0x1c, 0x92, 0xb3, 0x83, 0x06, 0x99, - 0xd0, 0x28, 0x80, 0x71, 0xe6, 0x87, 0x9e, 0xfd, 0x15, 0x94, 0x67, 0x08, 0xfc, 0x7b, 0x43, 0x1a, - 0xb3, 0xe0, 0x5e, 0x1b, 0x81, 0x14, 0x5a, 0x7d, 0x0f, 0xca, 0xb3, 0xcb, 0xe4, 0xab, 0x00, 0xfb, - 0x87, 0x9d, 0xce, 0xf1, 0x51, 0xbd, 0x73, 0xe8, 0x30, 0xcd, 0xfe, 0x8b, 0x0e, 0xc5, 0xfa, 0x60, - 0x10, 0x4d, 0xc3, 0xe4, 0xb5, 0x07, 0xf3, 0x55, 0x05, 0xfc, 0x10, 0x0a, 0xee, 0xb9, 0x9b, 0xb8, - 0x71, 0xfa, 0x22, 0xf8, 0xf1, 0x2b, 0x1e, 0xa4, 0xba, 0x6a, 0x75, 0x02, 0x89, 0x14, 0x6c, 0x7f, - 0x0d, 0x05, 0xb5, 0xc3, 0x3f, 0xc9, 0x5a, 0xe5, 0xd5, 0x83, 0x91, 0xfa, 0xcb, 0xbc, 0x1f, 0xbe, - 0x0b, 0xe6, 0x20, 0x0a, 0xa2, 0x58, 0xf9, 0x80, 0xfb, 0x24, 0x36, 0x4a, 0x99, 0x1b, 0xf6, 0x37, - 0x60, 0x12, 0xe7, 0x35, 0xef, 0x3f, 0x05, 0x73, 0xe2, 0x3f, 0x97, 0xea, 0xd5, 0xb5, 0xba, 0xf1, - 0xa3, 0xab, 0x0c, 0xd5, 0x7a, 0xfe, 0x73, 0xac, 0x58, 0xc4, 0x55, 0xef, 0x81, 0x81, 0x22, 0x16, - 0x6c, 0xa7, 0x2e, 0x76, 0x1c, 0xa6, 0xe1, 0xb2, 0xb7, 0x57, 0xef, 0x74, 0x98, 0x8e, 0xcb, 0x7e, - 0xeb, 0x70, 0xaf, 0xc1, 0x72, 0xf6, 0x1f, 0x75, 0x30, 0xa9, 0xbf, 0xfe, 0xbf, 0x36, 0x89, 0x74, - 0xc9, 0xe6, 0xd3, 0xd4, 0x66, 0x05, 0x8a, 0xbd, 0xe6, 0xf1, 0xe6, 0x2f, 0xd6, 0x71, 0xbe, 0x2a, - 0x61, 0xeb, 0xf3, 0xf5, 0xb1, 0xea, 0x60, 0xad, 0xe6, 0xf1, 0x67, 0x1b, 0xeb, 0x63, 0x96, 0xc3, - 0xb6, 0xd1, 0x6a, 0x1e, 0x3f, 0x58, 0xc7, 0x4f, 0x79, 0xea, 0x75, 0x28, 0x6e, 0x6d, 0xad, 0x8f, - 0x99, 0x91, 0x89, 0x1b, 0x0f, 0x50, 0x8b, 0xd9, 0xb8, 0xf3, 0xb7, 0x17, 0x6b, 0xfa, 0xf7, 0x2f, - 0xd6, 0xf4, 0x7f, 0xbf, 0x58, 0xd3, 0x7f, 0xf7, 0x72, 0x4d, 0xfb, 0xfe, 0xe5, 0x9a, 0xf6, 0xaf, - 0x97, 0x6b, 0xda, 0x6f, 0x72, 0xe3, 0x93, 0x93, 0x02, 0xfd, 0x99, 0xde, 0xfc, 0x5f, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x9d, 0x24, 0xb1, 0x57, 0x5c, 0x0f, 0x00, 0x00, + // 1651 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4f, 0x73, 0xe3, 0x48, + 0x15, 0x97, 0x64, 0xc9, 0x7f, 0x9e, 0x33, 0x99, 0xde, 0x66, 0x59, 0x84, 0x76, 0xc8, 0x66, 0xbd, + 0x05, 0x93, 0xfd, 0x83, 0xc9, 0x3f, 0xd8, 0x65, 0x8a, 0x61, 0x57, 0x8e, 0x35, 0xb1, 0x2b, 0x8a, + 0x1d, 0xda, 0x4e, 0x66, 0x87, 0x4b, 0x4a, 0xb1, 0x7a, 0x12, 0x55, 0x64, 0xc9, 0x2b, 0xcb, 0xd9, + 0xcd, 0x14, 0x1f, 0x82, 0x23, 0x67, 0xf8, 0x10, 0x54, 0x71, 0xe0, 0x46, 0x15, 0x17, 0xaa, 0xb6, + 0xb8, 0xc0, 0x91, 0x9a, 0xf9, 0x18, 0x5c, 0xa8, 0xd7, 0x2d, 0xd9, 0x4e, 0x36, 0x24, 0xa6, 0x98, + 0xcb, 0x9e, 0xdc, 0xaf, 0xf5, 0xfb, 0xbd, 0xf7, 0xfa, 0xd7, 0x4f, 0xaf, 0x5b, 0x86, 0xa5, 0x61, + 0xec, 0xf3, 0x70, 0x5c, 0x1f, 0x25, 0x71, 0x1a, 0xd3, 0x92, 0x17, 0x5d, 0xa6, 0x97, 0x23, 0x5e, + 0xfb, 0xdd, 0x2a, 0x18, 0xfb, 0xf8, 0xc4, 0xfa, 0xdb, 0xf7, 0xc0, 0x68, 0x84, 0xf1, 0xe0, 0x9c, + 0x2e, 0x83, 0x16, 0xf8, 0xa6, 0xba, 0xaa, 0xae, 0x55, 0x98, 0x16, 0xf8, 0xf4, 0xc7, 0x50, 0x7c, + 0x1e, 0xf0, 0xd0, 0x1f, 0x9b, 0xda, 0xaa, 0xba, 0x56, 0xdd, 0xfc, 0x6e, 0x3d, 0x63, 0xd7, 0x05, + 0xb3, 0xde, 0x4b, 0x93, 0xc9, 0x20, 0x65, 0x19, 0x88, 0x36, 0xa0, 0x3a, 0xe2, 0xc9, 0x30, 0x18, + 0x8f, 0x83, 0x38, 0x1a, 0x9b, 0x05, 0xc1, 0x59, 0xbd, 0xc6, 0x11, 0x91, 0xea, 0x07, 0x33, 0x1c, + 0x9b, 0x27, 0x51, 0x0b, 0xca, 0x83, 0xb3, 0x20, 0xf4, 0x13, 0x1e, 0x99, 0xfa, 0x6a, 0x61, 0xad, + 0xc2, 0xa6, 0x36, 0x7d, 0x02, 0x15, 0xdf, 0x1b, 0x9f, 0x9d, 0xc4, 0x5e, 0xe2, 0x9b, 0x55, 0xe1, + 0xfd, 0x47, 0x37, 0x7a, 0xdf, 0x89, 0xa3, 0x94, 0x47, 0x69, 0xbd, 0x99, 0xa3, 0x5b, 0x0a, 0x9b, + 0x51, 0xe9, 0xc7, 0xa0, 0x8f, 0xbc, 0x53, 0x6e, 0x2e, 0x09, 0x17, 0xef, 0xde, 0xea, 0xe2, 0xc0, + 0x3b, 0xe5, 0x2d, 0x85, 0x09, 0x02, 0xdd, 0x81, 0xb2, 0xef, 0xa5, 0xde, 0x45, 0xc0, 0xbf, 0x34, + 0xef, 0x09, 0xf2, 0x0f, 0xef, 0x88, 0x2f, 0xc1, 0x2d, 0x85, 0x4d, 0x89, 0x18, 0x3d, 0xe5, 0x5f, + 0xa5, 0xe6, 0xf2, 0x02, 0xd1, 0xfb, 0xfc, 0xab, 0x14, 0xa3, 0x23, 0x81, 0x3e, 0x02, 0xe3, 0x22, + 0xf0, 0x79, 0x6c, 0xde, 0x17, 0xcc, 0xda, 0xad, 0xcc, 0x23, 0x44, 0xb6, 0x14, 0x26, 0x29, 0xc8, + 0x0d, 0x86, 0xb8, 0x66, 0xb2, 0x00, 0xb7, 0x3d, 0x94, 0x8b, 0x96, 0x14, 0x4c, 0xf8, 0x79, 0x10, + 0x72, 0xf3, 0x8d, 0x05, 0x12, 0x7e, 0x12, 0x84, 0x42, 0x2e, 0x24, 0xd0, 0xc7, 0x50, 0x0c, 0xbd, + 0xcb, 0x78, 0x92, 0x9a, 0x54, 0x50, 0xdf, 0xbb, 0x95, 0xea, 0x0a, 0x68, 0x4b, 0x61, 0x19, 0x89, + 0x6e, 0x43, 0xc1, 0x0f, 0x2e, 0xcc, 0xef, 0xdc, 0x52, 0x46, 0x53, 0xa1, 0x83, 0x8b, 0x96, 0xc2, + 0x10, 0x6e, 0x5d, 0x42, 0x75, 0xae, 0xb8, 0x28, 0x05, 0x3d, 0xe1, 0x9e, 0x2c, 0xea, 0x32, 0x13, + 0x63, 0x9c, 0xe3, 0x7e, 0x90, 0x8a, 0xa2, 0x2e, 0x33, 0x31, 0xa6, 0x6f, 0x41, 0x31, 0xe1, 0xc3, + 0xf8, 0x82, 0x8b, 0xb2, 0x2d, 0xb3, 0xcc, 0x42, 0xac, 0x9f, 0x78, 0xa7, 0xa6, 0x2e, 0xb1, 0x38, + 0x46, 0xac, 0x9f, 0xc4, 0xa3, 0x6e, 0x64, 0x1a, 0x12, 0x2b, 0x2d, 0xeb, 0xdf, 0xf7, 0xa1, 0x94, + 0x65, 0x64, 0x9d, 0x42, 0x51, 0x2e, 0x88, 0x7e, 0x0a, 0xc6, 0x38, 0xbd, 0x0c, 0xb9, 0x48, 0x61, + 0x79, 0xf3, 0xfd, 0x05, 0x44, 0xa8, 0xf7, 0x90, 0xc0, 0x24, 0xaf, 0xf6, 0x00, 0x0c, 0x61, 0xd3, + 0x12, 0x14, 0x58, 0xf7, 0x29, 0x51, 0x28, 0x40, 0x71, 0xa7, 0xeb, 0x1e, 0xee, 0x77, 0x88, 0x6a, + 0x19, 0x50, 0x68, 0x06, 0x17, 0x56, 0x00, 0x95, 0x69, 0xb5, 0xd3, 0xc6, 0xd5, 0x90, 0x1f, 0x2d, + 0xf6, 0x92, 0x5c, 0x8d, 0x6a, 0xe6, 0x51, 0xef, 0x43, 0x75, 0xdf, 0x6e, 0x77, 0x8e, 0x7b, 0x3b, + 0xcc, 0x71, 0x3a, 0x44, 0xb1, 0x00, 0xca, 0x79, 0x61, 0x5b, 0xff, 0x30, 0x40, 0xc7, 0x22, 0x45, + 0x9d, 0x44, 0x55, 0xcb, 0xe6, 0x21, 0x0b, 0xf6, 0x71, 0x9e, 0x86, 0x26, 0xd2, 0x78, 0x78, 0x67, + 0xa9, 0x5f, 0xc9, 0x80, 0x3a, 0x50, 0x19, 0x7a, 0xc9, 0xf9, 0xd8, 0x0d, 0xc6, 0x69, 0xd6, 0x4c, + 0x16, 0x70, 0xb1, 0x8f, 0x14, 0x36, 0x63, 0xd2, 0x15, 0x80, 0x34, 0x3e, 0x3d, 0x0d, 0xb9, 0x77, + 0x12, 0xf2, 0x6c, 0x1f, 0xe7, 0x66, 0xa8, 0x0b, 0x80, 0x60, 0x9e, 0xf4, 0x2f, 0x47, 0x5c, 0xec, + 0xe8, 0x5d, 0x8a, 0x4d, 0xe3, 0x48, 0x0e, 0x9b, 0xe3, 0xd3, 0x07, 0x50, 0x19, 0x9c, 0xf1, 0xc1, + 0xb9, 0x08, 0x56, 0x14, 0xc1, 0x66, 0x13, 0xd4, 0x84, 0x92, 0x30, 0xb8, 0x6f, 0x96, 0xc4, 0xb3, + 0xdc, 0xb4, 0x1c, 0x30, 0x44, 0xe6, 0xf4, 0x17, 0x60, 0x88, 0xdc, 0x4d, 0x75, 0xb5, 0x70, 0x67, + 0x83, 0x9b, 0x66, 0xc2, 0x24, 0xc9, 0xfa, 0xbb, 0x0a, 0x3a, 0xda, 0xf4, 0x03, 0x30, 0x12, 0x2f, + 0x3a, 0x95, 0x25, 0x50, 0xdd, 0x7c, 0xf3, 0x9a, 0x1b, 0x86, 0xcf, 0x98, 0x84, 0xd0, 0x4f, 0x41, + 0xc7, 0x47, 0xd9, 0x36, 0x7d, 0xb8, 0x58, 0xc4, 0xba, 0x58, 0xba, 0x20, 0xd2, 0x37, 0xc1, 0x18, + 0x79, 0x89, 0x37, 0x14, 0xbb, 0x54, 0x61, 0xd2, 0xa8, 0xed, 0x82, 0x2e, 0x24, 0x79, 0x03, 0xee, + 0xf5, 0xfa, 0xac, 0xbd, 0xe7, 0xf4, 0x5b, 0xac, 0x7b, 0xb8, 0xdb, 0x22, 0x0a, 0x5d, 0x82, 0xf2, + 0x9e, 0xf3, 0xac, 0xd1, 0xb5, 0x59, 0x93, 0xa8, 0x58, 0xce, 0xed, 0xbe, 0xed, 0xb6, 0x77, 0x88, + 0x46, 0xcb, 0xa0, 0x37, 0xba, 0x6e, 0x93, 0x14, 0x70, 0xe4, 0xb6, 0x3b, 0x7b, 0x44, 0xaf, 0xed, + 0xe4, 0xa5, 0x68, 0x80, 0x3a, 0x22, 0x0a, 0x2d, 0x82, 0x76, 0xb6, 0x41, 0x54, 0xf1, 0xbb, 0x49, + 0x34, 0xf1, 0xbb, 0x45, 0x0a, 0xe2, 0x77, 0x9b, 0xe8, 0xb4, 0x02, 0xc6, 0x17, 0x93, 0x38, 0xe5, + 0xc4, 0x40, 0x27, 0x83, 0xd8, 0xe7, 0xa4, 0x58, 0xab, 0x03, 0xcc, 0xb6, 0x0c, 0xe7, 0xa3, 0x38, + 0xe2, 0xf2, 0x5d, 0x8a, 0x26, 0xc3, 0x13, 0x9e, 0xc8, 0x44, 0x4e, 0x26, 0x61, 0xc8, 0x53, 0xa2, + 0x59, 0x7f, 0xd1, 0xc0, 0x10, 0x4d, 0x54, 0x6c, 0x9a, 0x5c, 0x7d, 0x56, 0xdd, 0xb9, 0x49, 0x7f, + 0x89, 0x05, 0xee, 0xa5, 0xb9, 0x72, 0x6b, 0x77, 0x77, 0xe4, 0x7a, 0x0f, 0xf1, 0x4c, 0xd2, 0x68, + 0x13, 0x4a, 0xa3, 0x84, 0x8b, 0xe3, 0x44, 0xd6, 0xf7, 0x07, 0x0b, 0x78, 0x38, 0x90, 0x0c, 0x96, + 0x53, 0xad, 0x5f, 0x41, 0x29, 0x9b, 0xc3, 0xea, 0x4b, 0xcf, 0x26, 0xc3, 0x93, 0xc8, 0x0b, 0x42, + 0x91, 0xec, 0x12, 0x9b, 0x4d, 0xe0, 0x3b, 0x1a, 0x79, 0x43, 0x99, 0x6d, 0x85, 0x89, 0x31, 0x6e, + 0xdd, 0x97, 0x81, 0x9f, 0x9e, 0x89, 0x04, 0x0c, 0x26, 0x8d, 0x5a, 0x1b, 0x15, 0xc7, 0x0c, 0x2b, + 0x60, 0x38, 0xfb, 0x07, 0xfd, 0x67, 0x44, 0xa1, 0xf7, 0xa0, 0x72, 0x78, 0xe0, 0x76, 0xed, 0x66, + 0xbb, 0xb3, 0x4b, 0x54, 0x5a, 0x85, 0xd2, 0x01, 0x73, 0x8e, 0xda, 0xce, 0x53, 0xa2, 0x61, 0x8f, + 0x68, 0x76, 0x9f, 0x76, 0xf2, 0xa7, 0x62, 0xf3, 0x9a, 0xdd, 0x8e, 0x43, 0x74, 0xa1, 0xa3, 0x38, + 0x50, 0x5e, 0x97, 0x8e, 0xc2, 0xd9, 0xff, 0xa5, 0xa3, 0xf4, 0xf0, 0x2d, 0xd3, 0xf1, 0xf7, 0x1a, + 0xe8, 0x78, 0xba, 0xde, 0x22, 0xe3, 0xe3, 0xab, 0x32, 0x3e, 0xbc, 0xf3, 0xa4, 0xbe, 0xaa, 0xe2, + 0xce, 0x75, 0x15, 0xdf, 0xbf, 0xdb, 0xc1, 0x37, 0x44, 0xdc, 0x98, 0x89, 0x98, 0xcb, 0xa4, 0xce, + 0xc9, 0x44, 0x41, 0x0f, 0x06, 0x71, 0x94, 0x4b, 0x87, 0xe3, 0xd7, 0x29, 0xd2, 0x0b, 0xd0, 0xf1, + 0xc2, 0x36, 0x3b, 0x79, 0xd4, 0x05, 0x94, 0x38, 0x90, 0xf5, 0x34, 0x77, 0xf6, 0x6d, 0xe5, 0x0d, + 0x67, 0x2e, 0xa3, 0x32, 0xe8, 0x7d, 0xbb, 0xb7, 0x47, 0x54, 0x6c, 0x5e, 0x8d, 0x6e, 0x77, 0x6f, + 0xdf, 0x66, 0x7b, 0x44, 0xc3, 0x43, 0xb9, 0xe7, 0xf4, 0x49, 0xa1, 0xf6, 0x9b, 0xac, 0xdd, 0xdd, + 0x83, 0x4a, 0xd3, 0xee, 0xb5, 0x64, 0x73, 0x13, 0xbc, 0x03, 0x7b, 0xd7, 0x91, 0xbc, 0xa6, 0xdd, + 0xb7, 0xb3, 0x55, 0xa0, 0x3f, 0xe7, 0xf3, 0xbe, 0x4c, 0xff, 0x49, 0xdb, 0x75, 0x88, 0x2e, 0x96, + 0xd9, 0xde, 0xe9, 0x1f, 0x32, 0x87, 0x18, 0x18, 0xfb, 0xa8, 0xdd, 0x74, 0xba, 0xa4, 0x78, 0x25, + 0x62, 0x09, 0xbb, 0x94, 0x6b, 0x3f, 0xeb, 0x1e, 0xf6, 0x49, 0x19, 0xa3, 0x37, 0xdb, 0x47, 0xa4, + 0xd2, 0xa8, 0x4c, 0xab, 0xc2, 0xfa, 0x10, 0x0c, 0xd1, 0xde, 0x51, 0xec, 0xe7, 0x49, 0x3c, 0x14, + 0x22, 0x18, 0x4c, 0x8c, 0xf1, 0x8a, 0x9f, 0xc6, 0x42, 0x7e, 0x83, 0x69, 0x69, 0x6c, 0xfd, 0x51, + 0x87, 0xa2, 0xbc, 0xc6, 0xd3, 0x9f, 0x4f, 0x6f, 0xfb, 0xf2, 0xe8, 0x79, 0xf7, 0xc6, 0xdb, 0x7e, + 0xfd, 0x89, 0xc0, 0x38, 0x51, 0x9a, 0x5c, 0xe6, 0x37, 0x7f, 0xeb, 0x08, 0xaa, 0x73, 0xd3, 0x94, + 0x40, 0xe1, 0x9c, 0x5f, 0x66, 0x1b, 0x8f, 0x43, 0xba, 0x01, 0xc6, 0x85, 0x17, 0x4e, 0x78, 0xf6, + 0x21, 0xf1, 0xf6, 0xcd, 0xae, 0x8f, 0x10, 0xc2, 0x24, 0xf2, 0x91, 0xf6, 0x89, 0x6a, 0xfd, 0x09, + 0x9b, 0x30, 0x5a, 0xf4, 0x33, 0x80, 0x68, 0x12, 0x86, 0xc7, 0xd2, 0x8b, 0xdc, 0xd6, 0x77, 0x6e, + 0xf6, 0xd2, 0x99, 0x84, 0xa1, 0x20, 0xe1, 0xad, 0x3f, 0xca, 0x0d, 0xfa, 0x1e, 0x2c, 0xc9, 0x46, + 0x7f, 0x3c, 0xcb, 0x44, 0x6d, 0x29, 0xac, 0x2a, 0x67, 0xa7, 0xa0, 0x71, 0x9a, 0x04, 0xd1, 0x69, + 0x06, 0x12, 0x07, 0x1a, 0x82, 0xe4, 0xac, 0x04, 0xbd, 0x03, 0x70, 0x12, 0xc7, 0x79, 0x2e, 0xe2, + 0x46, 0x81, 0xa1, 0x70, 0x4e, 0x02, 0x1e, 0x09, 0x2f, 0x93, 0x41, 0x9a, 0x41, 0x8c, 0x5b, 0xbe, + 0x9e, 0x32, 0xe7, 0x93, 0x41, 0x3a, 0x5d, 0x68, 0x18, 0x8c, 0x73, 0x66, 0x51, 0x30, 0xff, 0xcb, + 0x42, 0xf1, 0x7a, 0x33, 0x5d, 0x68, 0x98, 0x1b, 0x8d, 0x22, 0xe8, 0xe7, 0x41, 0xe4, 0x5b, 0x9f, + 0x41, 0x65, 0x8a, 0xa0, 0x5b, 0x50, 0x14, 0x1e, 0xf3, 0xcd, 0xbd, 0x75, 0x07, 0x32, 0x68, 0xed, + 0x6d, 0xa8, 0x4c, 0xc5, 0xa4, 0xcb, 0x00, 0x9d, 0x43, 0xd7, 0x3d, 0x3e, 0xb2, 0xdd, 0x43, 0x87, + 0x28, 0xd6, 0x9f, 0x55, 0x28, 0xd9, 0x83, 0x41, 0x3c, 0x89, 0xd2, 0x6f, 0x7c, 0x38, 0xde, 0xd4, + 0x21, 0x7f, 0x0a, 0x45, 0xef, 0xc2, 0x4b, 0xbd, 0x24, 0xeb, 0x2e, 0x3f, 0xb8, 0x96, 0x41, 0xe6, + 0xab, 0x6e, 0x0b, 0x10, 0xcb, 0xc0, 0xd6, 0xe7, 0x50, 0x94, 0x33, 0xf4, 0xa3, 0xfc, 0x1b, 0xe6, + 0xe6, 0x2b, 0xcd, 0xb5, 0xaf, 0x96, 0xb7, 0xc0, 0x18, 0xc4, 0x61, 0x9c, 0xc8, 0x1c, 0x70, 0x5e, + 0x98, 0x8d, 0x72, 0x9e, 0x86, 0xf5, 0x45, 0x7e, 0x30, 0x5d, 0xcf, 0xfe, 0x27, 0x60, 0x8c, 0x83, + 0x17, 0x1c, 0xbf, 0x7a, 0x0b, 0x6b, 0xcb, 0x9b, 0xdf, 0xbf, 0x29, 0x50, 0xbd, 0x17, 0xbc, 0xc0, + 0x7e, 0x81, 0xb8, 0xda, 0x43, 0xd0, 0xd1, 0xc4, 0x57, 0xd6, 0xb5, 0xd9, 0xae, 0x43, 0x14, 0x1c, + 0xf6, 0xf6, 0x6d, 0xd7, 0x25, 0x2a, 0x0e, 0xfb, 0xad, 0xc3, 0xfd, 0x06, 0xd1, 0xac, 0x3f, 0xa8, + 0xf9, 0xa5, 0xe2, 0x7f, 0x8c, 0x99, 0x5d, 0x1e, 0xe6, 0x62, 0x3e, 0xcb, 0x62, 0x56, 0xa1, 0xd4, + 0x6b, 0x1e, 0x6f, 0xfd, 0x6c, 0x1d, 0x6f, 0x46, 0xd2, 0xd8, 0xfe, 0x64, 0x7d, 0x24, 0x9b, 0x66, + 0xab, 0x79, 0xfc, 0xf1, 0xe6, 0xfa, 0x88, 0x68, 0xd8, 0x42, 0x5a, 0xcd, 0xe3, 0x8d, 0x75, 0x7c, + 0x54, 0x10, 0xed, 0x15, 0xcd, 0xed, 0xed, 0xf5, 0x11, 0xd1, 0x73, 0x73, 0x73, 0x03, 0xbd, 0x18, + 0x8d, 0x07, 0x7f, 0x7d, 0xb9, 0xa2, 0x7e, 0xfd, 0x72, 0x45, 0xfd, 0xd7, 0xcb, 0x15, 0xf5, 0xb7, + 0xaf, 0x56, 0x94, 0xaf, 0x5f, 0xad, 0x28, 0xff, 0x7c, 0xb5, 0xa2, 0xfc, 0x5a, 0x1b, 0x9d, 0x9c, + 0x14, 0xc5, 0x1f, 0x09, 0x5b, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x91, 0x1e, 0x3b, 0x5d, 0x58, + 0x10, 0x00, 0x00, } func (m *Model) Marshal() (dAtA []byte, err error) { @@ -2195,12 +2297,12 @@ func (m *ModelBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.Children[iNdEx]) i = encodeVarintModels(dAtA, i, uint64(len(m.Children[iNdEx]))) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x22 } } - if m.Header != nil { + if m.Permissions != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Permissions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2208,6 +2310,25 @@ func (m *ModelBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 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 @@ -2297,16 +2418,16 @@ func (m *ModelBlockContentOfText) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } -func (m *ModelBlockContentOfMedia) MarshalTo(dAtA []byte) (int, error) { +func (m *ModelBlockContentOfVideo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ModelBlockContentOfMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ModelBlockContentOfVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.Media != nil { + if m.Video != nil { { - size, err := m.Media.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Video.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2318,6 +2439,52 @@ func (m *ModelBlockContentOfMedia) MarshalToSizedBuffer(dAtA []byte) (int, error } return len(dAtA) - i, nil } +func (m *ModelBlockContentOfImage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ModelBlockContentOfImage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Image != nil { + { + size, err := m.Image.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 *ModelBlockContentOfFile) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ModelBlockContentOfFile) 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] = 0x1 + i-- + dAtA[i] = 0x8a + } + return len(dAtA) - i, nil +} func (m *ModelBlockContentOfLayout) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) @@ -2337,7 +2504,7 @@ func (m *ModelBlockContentOfLayout) MarshalToSizedBuffer(dAtA []byte) (int, erro i-- dAtA[i] = 0x1 i-- - dAtA[i] = 0x82 + dAtA[i] = 0x92 } return len(dAtA) - i, nil } @@ -2360,11 +2527,11 @@ func (m *ModelBlockContentOfDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x1 i-- - dAtA[i] = 0x8a + dAtA[i] = 0x9a } return len(dAtA) - i, nil } -func (m *ModelBlockHeader) Marshal() (dAtA []byte, err error) { +func (m *ModelBlockPermissions) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2374,71 +2541,12 @@ func (m *ModelBlockHeader) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ModelBlockHeader) MarshalTo(dAtA []byte) (int, error) { +func (m *ModelBlockPermissions) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ModelBlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Permissions != nil { - { - size, err := m.Permissions.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - 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.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 *ModelBlockHeaderPermissions) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ModelBlockHeaderPermissions) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ModelBlockHeaderPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ModelBlockPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2590,20 +2698,6 @@ func (m *ModelBlockContentDashboard) MarshalToSizedBuffer(dAtA []byte) (int, err _ = i var l int _ = l - if len(m.Headers) > 0 { - for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } if m.Style != 0 { i = encodeVarintModels(dAtA, i, uint64(m.Style)) i-- @@ -2801,7 +2895,7 @@ func (m *ModelBlockContentTextMark) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } -func (m *ModelBlockContentMedia) Marshal() (dAtA []byte, err error) { +func (m *ModelBlockContentVideo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2811,24 +2905,27 @@ func (m *ModelBlockContentMedia) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ModelBlockContentMedia) MarshalTo(dAtA []byte) (int, error) { +func (m *ModelBlockContentVideo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ModelBlockContentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ModelBlockContentVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Preview != nil { { - size := m.Preview.Size() - i -= size - if _, err := m.Preview.MarshalTo(dAtA[i:]); err != nil { + size, err := m.Preview.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { return 0, err } + i -= size + i = encodeVarintModels(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x1a } if m.State != 0 { i = encodeVarintModels(dAtA, i, uint64(m.State)) @@ -2845,76 +2942,7 @@ func (m *ModelBlockContentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *ModelBlockContentMediaPreviewOfVideo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ModelBlockContentMediaPreviewOfVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Video != nil { - { - size, err := m.Video.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x6 - i-- - dAtA[i] = 0xaa - } - return len(dAtA) - i, nil -} -func (m *ModelBlockContentMediaPreviewOfImage) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ModelBlockContentMediaPreviewOfImage) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.Image != nil { - { - size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintModels(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x6 - i-- - dAtA[i] = 0xb2 - } - return len(dAtA) - i, nil -} -func (m *ModelBlockContentMediaPreviewOfFile) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ModelBlockContentMediaPreviewOfFile) 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] = 0x6 - i-- - dAtA[i] = 0xba - } - return len(dAtA) - i, nil -} -func (m *ModelBlockContentMediaVideoPreview) Marshal() (dAtA []byte, err error) { +func (m *ModelBlockContentVideoPreview) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2924,12 +2952,12 @@ func (m *ModelBlockContentMediaVideoPreview) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *ModelBlockContentMediaVideoPreview) MarshalTo(dAtA []byte) (int, error) { +func (m *ModelBlockContentVideoPreview) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ModelBlockContentMediaVideoPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ModelBlockContentVideoPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2956,7 +2984,7 @@ func (m *ModelBlockContentMediaVideoPreview) MarshalToSizedBuffer(dAtA []byte) ( return len(dAtA) - i, nil } -func (m *ModelBlockContentMediaImagePreview) Marshal() (dAtA []byte, err error) { +func (m *ModelBlockContentImage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2966,12 +2994,59 @@ func (m *ModelBlockContentMediaImagePreview) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *ModelBlockContentMediaImagePreview) MarshalTo(dAtA []byte) (int, error) { +func (m *ModelBlockContentImage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ModelBlockContentMediaImagePreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ModelBlockContentImage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Preview != nil { + { + size, err := m.Preview.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintModels(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.State != 0 { + i = encodeVarintModels(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x10 + } + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintModels(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ModelBlockContentImagePreview) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModelBlockContentImagePreview) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ModelBlockContentImagePreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2998,7 +3073,7 @@ func (m *ModelBlockContentMediaImagePreview) MarshalToSizedBuffer(dAtA []byte) ( return len(dAtA) - i, nil } -func (m *ModelBlockContentMediaFilePreview) Marshal() (dAtA []byte, err error) { +func (m *ModelBlockContentFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3008,12 +3083,59 @@ func (m *ModelBlockContentMediaFilePreview) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ModelBlockContentMediaFilePreview) MarshalTo(dAtA []byte) (int, error) { +func (m *ModelBlockContentFile) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ModelBlockContentMediaFilePreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ModelBlockContentFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Preview != nil { + { + size, err := m.Preview.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintModels(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.State != 0 { + i = encodeVarintModels(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x10 + } + if len(m.Content) > 0 { + i -= len(m.Content) + copy(dAtA[i:], m.Content) + i = encodeVarintModels(dAtA, i, uint64(len(m.Content))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ModelBlockContentFilePreview) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ModelBlockContentFilePreview) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ModelBlockContentFilePreview) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -3449,20 +3571,20 @@ func (m *ModelImage) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.Sizes) > 0 { - dAtA22 := make([]byte, len(m.Sizes)*10) - var j21 int + dAtA23 := make([]byte, len(m.Sizes)*10) + var j22 int for _, num := range m.Sizes { for num >= 1<<7 { - dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80) + dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j21++ + j22++ } - dAtA22[j21] = uint8(num) - j21++ + dAtA23[j22] = uint8(num) + j22++ } - i -= j21 - copy(dAtA[i:], dAtA22[:j21]) - i = encodeVarintModels(dAtA, i, uint64(j21)) + i -= j22 + copy(dAtA[i:], dAtA23[:j22]) + i = encodeVarintModels(dAtA, i, uint64(j22)) i-- dAtA[i] = 0x12 } @@ -3497,20 +3619,20 @@ func (m *ModelVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.Sizes) > 0 { - dAtA24 := make([]byte, len(m.Sizes)*10) - var j23 int + dAtA25 := make([]byte, len(m.Sizes)*10) + var j24 int for _, num := range m.Sizes { for num >= 1<<7 { - dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80) + dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j23++ + j24++ } - dAtA24[j23] = uint8(num) - j23++ + dAtA25[j24] = uint8(num) + j24++ } - i -= j23 - copy(dAtA[i:], dAtA24[:j23]) - i = encodeVarintModels(dAtA, i, uint64(j23)) + i -= j24 + copy(dAtA[i:], dAtA25[:j24]) + i = encodeVarintModels(dAtA, i, uint64(j24)) i-- dAtA[i] = 0x12 } @@ -3550,8 +3672,16 @@ func (m *ModelBlock) Size() (n int) { } var l int _ = l - if m.Header != nil { - l = m.Header.Size() + 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.Permissions != nil { + l = m.Permissions.Size() n += 1 + l + sovModels(uint64(l)) } if len(m.Children) > 0 { @@ -3614,18 +3744,42 @@ func (m *ModelBlockContentOfText) Size() (n int) { } return n } -func (m *ModelBlockContentOfMedia) Size() (n int) { +func (m *ModelBlockContentOfVideo) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Media != nil { - l = m.Media.Size() + if m.Video != nil { + l = m.Video.Size() n += 1 + l + sovModels(uint64(l)) } return n } +func (m *ModelBlockContentOfImage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Image != nil { + l = m.Image.Size() + n += 2 + l + sovModels(uint64(l)) + } + return n +} +func (m *ModelBlockContentOfFile) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.File != nil { + l = m.File.Size() + n += 2 + l + sovModels(uint64(l)) + } + return n +} func (m *ModelBlockContentOfLayout) Size() (n int) { if m == nil { return 0 @@ -3650,31 +3804,7 @@ func (m *ModelBlockContentOfDiv) Size() (n int) { } return n } -func (m *ModelBlockHeader) 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)) - } - if m.Fields != nil { - l = m.Fields.Size() - n += 1 + l + sovModels(uint64(l)) - } - if m.Permissions != nil { - l = m.Permissions.Size() - n += 1 + l + sovModels(uint64(l)) - } - return n -} - -func (m *ModelBlockHeaderPermissions) Size() (n int) { +func (m *ModelBlockPermissions) Size() (n int) { if m == nil { return 0 } @@ -3737,12 +3867,6 @@ func (m *ModelBlockContentDashboard) Size() (n int) { if m.Style != 0 { n += 1 + sovModels(uint64(m.Style)) } - if len(m.Headers) > 0 { - for _, e := range m.Headers { - l = e.Size() - n += 1 + l + sovModels(uint64(l)) - } - } return n } @@ -3822,7 +3946,7 @@ func (m *ModelBlockContentTextMark) Size() (n int) { return n } -func (m *ModelBlockContentMedia) Size() (n int) { +func (m *ModelBlockContentVideo) Size() (n int) { if m == nil { return 0 } @@ -3836,48 +3960,13 @@ func (m *ModelBlockContentMedia) Size() (n int) { n += 1 + sovModels(uint64(m.State)) } if m.Preview != nil { - n += m.Preview.Size() + l = m.Preview.Size() + n += 1 + l + sovModels(uint64(l)) } return n } -func (m *ModelBlockContentMediaPreviewOfVideo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Video != nil { - l = m.Video.Size() - n += 2 + l + sovModels(uint64(l)) - } - return n -} -func (m *ModelBlockContentMediaPreviewOfImage) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Image != nil { - l = m.Image.Size() - n += 2 + l + sovModels(uint64(l)) - } - return n -} -func (m *ModelBlockContentMediaPreviewOfFile) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.File != nil { - l = m.File.Size() - n += 2 + l + sovModels(uint64(l)) - } - return n -} -func (m *ModelBlockContentMediaVideoPreview) Size() (n int) { +func (m *ModelBlockContentVideoPreview) Size() (n int) { if m == nil { return 0 } @@ -3897,7 +3986,27 @@ func (m *ModelBlockContentMediaVideoPreview) Size() (n int) { return n } -func (m *ModelBlockContentMediaImagePreview) Size() (n int) { +func (m *ModelBlockContentImage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Content) + if l > 0 { + n += 1 + l + sovModels(uint64(l)) + } + if m.State != 0 { + n += 1 + sovModels(uint64(m.State)) + } + if m.Preview != nil { + l = m.Preview.Size() + n += 1 + l + sovModels(uint64(l)) + } + return n +} + +func (m *ModelBlockContentImagePreview) Size() (n int) { if m == nil { return 0 } @@ -3917,7 +4026,27 @@ func (m *ModelBlockContentMediaImagePreview) Size() (n int) { return n } -func (m *ModelBlockContentMediaFilePreview) Size() (n int) { +func (m *ModelBlockContentFile) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Content) + if l > 0 { + n += 1 + l + sovModels(uint64(l)) + } + if m.State != 0 { + n += 1 + sovModels(uint64(m.State)) + } + if m.Preview != nil { + l = m.Preview.Size() + n += 1 + l + sovModels(uint64(l)) + } + return n +} + +func (m *ModelBlockContentFilePreview) Size() (n int) { if m == nil { return 0 } @@ -4256,7 +4385,39 @@ func (m *ModelBlock) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + 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 { @@ -4283,14 +4444,50 @@ func (m *ModelBlock) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ModelBlockHeader{} + if m.Fields == nil { + m.Fields = &ModelStruct{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Permissions", 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.Permissions == nil { + m.Permissions = &ModelBlockPermissions{} + } + if err := m.Permissions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Children", wireType) } @@ -4464,7 +4661,7 @@ func (m *ModelBlock) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Media", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Video", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4491,13 +4688,83 @@ func (m *ModelBlock) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ModelBlockContentMedia{} + v := &ModelBlockContentVideo{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Content = &ModelBlockContentOfMedia{v} + m.Content = &ModelBlockContentOfVideo{v} iNdEx = postIndex case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Image", 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 := &ModelBlockContentImage{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Content = &ModelBlockContentOfImage{v} + iNdEx = postIndex + case 17: + 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 := &ModelBlockContentFile{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Content = &ModelBlockContentOfFile{v} + iNdEx = postIndex + case 18: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Layout", wireType) } @@ -4532,7 +4799,7 @@ func (m *ModelBlock) Unmarshal(dAtA []byte) error { } m.Content = &ModelBlockContentOfLayout{v} iNdEx = postIndex - case 17: + case 19: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Div", wireType) } @@ -4591,183 +4858,7 @@ func (m *ModelBlock) Unmarshal(dAtA []byte) error { } return nil } -func (m *ModelBlockHeader) Unmarshal(dAtA []byte) 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: Header: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Header: 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 |= ModelBlockHeaderType(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 = &ModelStruct{} - } - if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Permissions", 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.Permissions == nil { - m.Permissions = &ModelBlockHeaderPermissions{} - } - if err := m.Permissions.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 { - return ErrInvalidLengthModels - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthModels - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ModelBlockHeaderPermissions) Unmarshal(dAtA []byte) error { +func (m *ModelBlockPermissions) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5146,40 +5237,6 @@ func (m *ModelBlockContentDashboard) Unmarshal(dAtA []byte) error { break } } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Headers", 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.Headers = append(m.Headers, &ModelBlockHeader{}) - if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipModels(dAtA[iNdEx:]) @@ -5703,7 +5760,7 @@ func (m *ModelBlockContentTextMark) Unmarshal(dAtA []byte) error { } return nil } -func (m *ModelBlockContentMedia) Unmarshal(dAtA []byte) error { +func (m *ModelBlockContentVideo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5726,17 +5783,17 @@ func (m *ModelBlockContentMedia) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Media: wiretype end group for non-group") + return fmt.Errorf("proto: Video: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Media: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Video: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowModels @@ -5746,25 +5803,23 @@ func (m *ModelBlockContentMedia) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthModels } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthModels } if postIndex > l { return io.ErrUnexpectedEOF } - m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...) - if m.Content == nil { - m.Content = []byte{} - } + m.Content = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { @@ -5780,14 +5835,14 @@ func (m *ModelBlockContentMedia) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.State |= ModelBlockContentMediaState(b&0x7F) << shift + m.State |= ModelBlockContentVideoState(b&0x7F) << shift if b < 0x80 { break } } - case 101: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Video", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Preview", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5814,81 +5869,12 @@ func (m *ModelBlockContentMedia) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ModelBlockContentMediaVideoPreview{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Preview == nil { + m.Preview = &ModelBlockContentVideoPreview{} + } + if err := m.Preview.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Preview = &ModelBlockContentMediaPreviewOfVideo{v} - iNdEx = postIndex - case 102: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Image", 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 := &ModelBlockContentMediaImagePreview{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Preview = &ModelBlockContentMediaPreviewOfImage{v} - iNdEx = postIndex - case 103: - 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 := &ModelBlockContentMediaFilePreview{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Preview = &ModelBlockContentMediaPreviewOfFile{v} iNdEx = postIndex default: iNdEx = preIndex @@ -5914,7 +5900,7 @@ func (m *ModelBlockContentMedia) Unmarshal(dAtA []byte) error { } return nil } -func (m *ModelBlockContentMediaVideoPreview) Unmarshal(dAtA []byte) error { +func (m *ModelBlockContentVideoPreview) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5937,10 +5923,10 @@ func (m *ModelBlockContentMediaVideoPreview) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: VideoPreview: wiretype end group for non-group") + return fmt.Errorf("proto: Preview: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: VideoPreview: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Preview: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -6052,7 +6038,7 @@ func (m *ModelBlockContentMediaVideoPreview) Unmarshal(dAtA []byte) error { } return nil } -func (m *ModelBlockContentMediaImagePreview) Unmarshal(dAtA []byte) error { +func (m *ModelBlockContentImage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -6075,10 +6061,150 @@ func (m *ModelBlockContentMediaImagePreview) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ImagePreview: wiretype end group for non-group") + return fmt.Errorf("proto: Image: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ImagePreview: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Content", 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.Content = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + 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 |= ModelBlockContentImageState(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Preview", 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.Preview == nil { + m.Preview = &ModelBlockContentImagePreview{} + } + if err := m.Preview.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 { + return ErrInvalidLengthModels + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthModels + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ModelBlockContentImagePreview) Unmarshal(dAtA []byte) 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: Preview: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Preview: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -6190,7 +6316,7 @@ func (m *ModelBlockContentMediaImagePreview) Unmarshal(dAtA []byte) error { } return nil } -func (m *ModelBlockContentMediaFilePreview) Unmarshal(dAtA []byte) error { +func (m *ModelBlockContentFile) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -6213,10 +6339,150 @@ func (m *ModelBlockContentMediaFilePreview) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: FilePreview: wiretype end group for non-group") + return fmt.Errorf("proto: File: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: FilePreview: illegal tag %d (wire type %d)", fieldNum, wire) + 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 Content", 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.Content = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + 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 |= ModelBlockContentFileState(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Preview", 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.Preview == nil { + m.Preview = &ModelBlockContentFilePreview{} + } + if err := m.Preview.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 { + return ErrInvalidLengthModels + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthModels + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ModelBlockContentFilePreview) Unmarshal(dAtA []byte) 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: Preview: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Preview: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: diff --git a/pb/protos/commands.proto b/pb/protos/commands.proto index a9d036ebc..f0ceb9669 100644 --- a/pb/protos/commands.proto +++ b/pb/protos/commands.proto @@ -58,7 +58,7 @@ message Rpc { message Create { message Request { - Model.Block.Type type = 1; + Model.Block block = 1; string contextBlockId = 2; } @@ -81,7 +81,7 @@ message Rpc { message Update { message Request { - BlockChanges changes = 1; + Change.Multiple.BlocksList changes = 1; } message Response { diff --git a/pb/protos/events.proto b/pb/protos/events.proto index bae4b3b66..6e8598e01 100644 --- a/pb/protos/events.proto +++ b/pb/protos/events.proto @@ -36,7 +36,7 @@ message Event { } message Update { - BlockChanges changes = 1; + Change.Multiple.BlocksList changes = 1; } message Create {