anytype-heart/pb/commands.pb.go

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

package pb

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

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

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

type RpcMetricsSetParametersResponseErrorCode int32

const (
	RpcMetricsSetParametersResponseError_NULL          RpcMetricsSetParametersResponseErrorCode = 0
	RpcMetricsSetParametersResponseError_UNKNOWN_ERROR RpcMetricsSetParametersResponseErrorCode = 1
	RpcMetricsSetParametersResponseError_BAD_INPUT     RpcMetricsSetParametersResponseErrorCode = 2
)

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

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

func (x RpcMetricsSetParametersResponseErrorCode) String() string {
	return proto.EnumName(RpcMetricsSetParametersResponseErrorCode_name, int32(x))
}

func (RpcMetricsSetParametersResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 0, 0, 1, 0, 0}
}

type RpcExternalDropFilesResponseErrorCode int32

const (
	RpcExternalDropFilesResponseError_NULL          RpcExternalDropFilesResponseErrorCode = 0
	RpcExternalDropFilesResponseError_UNKNOWN_ERROR RpcExternalDropFilesResponseErrorCode = 1
	RpcExternalDropFilesResponseError_BAD_INPUT     RpcExternalDropFilesResponseErrorCode = 2
)

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

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

func (x RpcExternalDropFilesResponseErrorCode) String() string {
	return proto.EnumName(RpcExternalDropFilesResponseErrorCode_name, int32(x))
}

func (RpcExternalDropFilesResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 1, 0, 1, 0, 0}
}

type RpcExternalDropContentResponseErrorCode int32

const (
	RpcExternalDropContentResponseError_NULL          RpcExternalDropContentResponseErrorCode = 0
	RpcExternalDropContentResponseError_UNKNOWN_ERROR RpcExternalDropContentResponseErrorCode = 1
	RpcExternalDropContentResponseError_BAD_INPUT     RpcExternalDropContentResponseErrorCode = 2
)

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

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

func (x RpcExternalDropContentResponseErrorCode) String() string {
	return proto.EnumName(RpcExternalDropContentResponseErrorCode_name, int32(x))
}

func (RpcExternalDropContentResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 1, 1, 1, 0, 0}
}

type RpcBlockListConvertChildrenToPagesResponseErrorCode int32

const (
	RpcBlockListConvertChildrenToPagesResponseError_NULL          RpcBlockListConvertChildrenToPagesResponseErrorCode = 0
	RpcBlockListConvertChildrenToPagesResponseError_UNKNOWN_ERROR RpcBlockListConvertChildrenToPagesResponseErrorCode = 1
	RpcBlockListConvertChildrenToPagesResponseError_BAD_INPUT     RpcBlockListConvertChildrenToPagesResponseErrorCode = 2
)

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

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

func (x RpcBlockListConvertChildrenToPagesResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListConvertChildrenToPagesResponseErrorCode_name, int32(x))
}

func (RpcBlockListConvertChildrenToPagesResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 0, 1, 0, 0}
}

type RpcBlockListMoveResponseErrorCode int32

const (
	RpcBlockListMoveResponseError_NULL          RpcBlockListMoveResponseErrorCode = 0
	RpcBlockListMoveResponseError_UNKNOWN_ERROR RpcBlockListMoveResponseErrorCode = 1
	RpcBlockListMoveResponseError_BAD_INPUT     RpcBlockListMoveResponseErrorCode = 2
)

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

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

func (x RpcBlockListMoveResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListMoveResponseErrorCode_name, int32(x))
}

func (RpcBlockListMoveResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 1, 1, 0, 0}
}

type RpcBlockListMoveToNewPageResponseErrorCode int32

const (
	RpcBlockListMoveToNewPageResponseError_NULL          RpcBlockListMoveToNewPageResponseErrorCode = 0
	RpcBlockListMoveToNewPageResponseError_UNKNOWN_ERROR RpcBlockListMoveToNewPageResponseErrorCode = 1
	RpcBlockListMoveToNewPageResponseError_BAD_INPUT     RpcBlockListMoveToNewPageResponseErrorCode = 2
)

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

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

func (x RpcBlockListMoveToNewPageResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListMoveToNewPageResponseErrorCode_name, int32(x))
}

func (RpcBlockListMoveToNewPageResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 2, 1, 0, 0}
}

type RpcBlockListDuplicateResponseErrorCode int32

const (
	RpcBlockListDuplicateResponseError_NULL          RpcBlockListDuplicateResponseErrorCode = 0
	RpcBlockListDuplicateResponseError_UNKNOWN_ERROR RpcBlockListDuplicateResponseErrorCode = 1
	RpcBlockListDuplicateResponseError_BAD_INPUT     RpcBlockListDuplicateResponseErrorCode = 2
)

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

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

func (x RpcBlockListDuplicateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListDuplicateResponseErrorCode_name, int32(x))
}

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

type RpcBlockListSetTextStyleResponseErrorCode int32

const (
	RpcBlockListSetTextStyleResponseError_NULL          RpcBlockListSetTextStyleResponseErrorCode = 0
	RpcBlockListSetTextStyleResponseError_UNKNOWN_ERROR RpcBlockListSetTextStyleResponseErrorCode = 1
	RpcBlockListSetTextStyleResponseError_BAD_INPUT     RpcBlockListSetTextStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetTextStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetTextStyleResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetTextStyleResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 0, 0, 1, 0, 0}
}

type RpcBlockListSetTextColorResponseErrorCode int32

const (
	RpcBlockListSetTextColorResponseError_NULL          RpcBlockListSetTextColorResponseErrorCode = 0
	RpcBlockListSetTextColorResponseError_UNKNOWN_ERROR RpcBlockListSetTextColorResponseErrorCode = 1
	RpcBlockListSetTextColorResponseError_BAD_INPUT     RpcBlockListSetTextColorResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetTextColorResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetTextColorResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetTextColorResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 0, 1, 1, 0, 0}
}

type RpcBlockListSetTextMarkResponseErrorCode int32

const (
	RpcBlockListSetTextMarkResponseError_NULL          RpcBlockListSetTextMarkResponseErrorCode = 0
	RpcBlockListSetTextMarkResponseError_UNKNOWN_ERROR RpcBlockListSetTextMarkResponseErrorCode = 1
	RpcBlockListSetTextMarkResponseError_BAD_INPUT     RpcBlockListSetTextMarkResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetTextMarkResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetTextMarkResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetTextMarkResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 0, 2, 1, 0, 0}
}

type RpcBlockListSetBackgroundColorResponseErrorCode int32

const (
	RpcBlockListSetBackgroundColorResponseError_NULL          RpcBlockListSetBackgroundColorResponseErrorCode = 0
	RpcBlockListSetBackgroundColorResponseError_UNKNOWN_ERROR RpcBlockListSetBackgroundColorResponseErrorCode = 1
	RpcBlockListSetBackgroundColorResponseError_BAD_INPUT     RpcBlockListSetBackgroundColorResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetBackgroundColorResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetBackgroundColorResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetBackgroundColorResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 1, 1, 0, 0}
}

type RpcBlockListSetAlignResponseErrorCode int32

const (
	RpcBlockListSetAlignResponseError_NULL          RpcBlockListSetAlignResponseErrorCode = 0
	RpcBlockListSetAlignResponseError_UNKNOWN_ERROR RpcBlockListSetAlignResponseErrorCode = 1
	RpcBlockListSetAlignResponseError_BAD_INPUT     RpcBlockListSetAlignResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetAlignResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetAlignResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetAlignResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 2, 1, 0, 0}
}

type RpcBlockListSetFieldsResponseErrorCode int32

const (
	RpcBlockListSetFieldsResponseError_NULL          RpcBlockListSetFieldsResponseErrorCode = 0
	RpcBlockListSetFieldsResponseError_UNKNOWN_ERROR RpcBlockListSetFieldsResponseErrorCode = 1
	RpcBlockListSetFieldsResponseError_BAD_INPUT     RpcBlockListSetFieldsResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetFieldsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetFieldsResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetFieldsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 3, 1, 0, 0}
}

type RpcBlockListSetDivStyleResponseErrorCode int32

const (
	RpcBlockListSetDivStyleResponseError_NULL          RpcBlockListSetDivStyleResponseErrorCode = 0
	RpcBlockListSetDivStyleResponseError_UNKNOWN_ERROR RpcBlockListSetDivStyleResponseErrorCode = 1
	RpcBlockListSetDivStyleResponseError_BAD_INPUT     RpcBlockListSetDivStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetDivStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetDivStyleResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetDivStyleResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 4, 0, 1, 0, 0}
}

type RpcBlockListSetFileStyleResponseErrorCode int32

const (
	RpcBlockListSetFileStyleResponseError_NULL          RpcBlockListSetFileStyleResponseErrorCode = 0
	RpcBlockListSetFileStyleResponseError_UNKNOWN_ERROR RpcBlockListSetFileStyleResponseErrorCode = 1
	RpcBlockListSetFileStyleResponseError_BAD_INPUT     RpcBlockListSetFileStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetFileStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetFileStyleResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetFileStyleResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 4, 5, 0, 1, 0, 0}
}

type RpcBlockListTurnIntoResponseErrorCode int32

const (
	RpcBlockListTurnIntoResponseError_NULL          RpcBlockListTurnIntoResponseErrorCode = 0
	RpcBlockListTurnIntoResponseError_UNKNOWN_ERROR RpcBlockListTurnIntoResponseErrorCode = 1
	RpcBlockListTurnIntoResponseError_BAD_INPUT     RpcBlockListTurnIntoResponseErrorCode = 2
)

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

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

func (x RpcBlockListTurnIntoResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListTurnIntoResponseErrorCode_name, int32(x))
}

func (RpcBlockListTurnIntoResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 5, 1, 0, 0}
}

type RpcBlockReplaceResponseErrorCode int32

const (
	RpcBlockReplaceResponseError_NULL          RpcBlockReplaceResponseErrorCode = 0
	RpcBlockReplaceResponseError_UNKNOWN_ERROR RpcBlockReplaceResponseErrorCode = 1
	RpcBlockReplaceResponseError_BAD_INPUT     RpcBlockReplaceResponseErrorCode = 2
)

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

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

func (x RpcBlockReplaceResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockReplaceResponseErrorCode_name, int32(x))
}

func (RpcBlockReplaceResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 0, 1, 0, 0}
}

type RpcBlockUpdateContentResponseErrorCode int32

const (
	RpcBlockUpdateContentResponseError_NULL          RpcBlockUpdateContentResponseErrorCode = 0
	RpcBlockUpdateContentResponseError_UNKNOWN_ERROR RpcBlockUpdateContentResponseErrorCode = 1
	RpcBlockUpdateContentResponseError_BAD_INPUT     RpcBlockUpdateContentResponseErrorCode = 2
)

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

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

func (x RpcBlockUpdateContentResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockUpdateContentResponseErrorCode_name, int32(x))
}

func (RpcBlockUpdateContentResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 1, 1, 0, 0}
}

type RpcBlockSplitRequestMode int32

const (
	// new block will be created under existing
	RpcBlockSplitRequest_BOTTOM RpcBlockSplitRequestMode = 0
	// new block will be created above existing
	RpcBlockSplitRequest_TOP RpcBlockSplitRequestMode = 1
	// new block will be created as the first children of existing
	RpcBlockSplitRequest_INNER RpcBlockSplitRequestMode = 2
	// new block will be created after header (not required for set at client side, will auto set for title block)
	RpcBlockSplitRequest_TITLE RpcBlockSplitRequestMode = 3
)

var RpcBlockSplitRequestMode_name = map[int32]string{
	0: "BOTTOM",
	1: "TOP",
	2: "INNER",
	3: "TITLE",
}

var RpcBlockSplitRequestMode_value = map[string]int32{
	"BOTTOM": 0,
	"TOP":    1,
	"INNER":  2,
	"TITLE":  3,
}

func (x RpcBlockSplitRequestMode) String() string {
	return proto.EnumName(RpcBlockSplitRequestMode_name, int32(x))
}

func (RpcBlockSplitRequestMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 2, 0, 0}
}

type RpcBlockSplitResponseErrorCode int32

const (
	RpcBlockSplitResponseError_NULL          RpcBlockSplitResponseErrorCode = 0
	RpcBlockSplitResponseError_UNKNOWN_ERROR RpcBlockSplitResponseErrorCode = 1
	RpcBlockSplitResponseError_BAD_INPUT     RpcBlockSplitResponseErrorCode = 2
)

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

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

func (x RpcBlockSplitResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSplitResponseErrorCode_name, int32(x))
}

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

type RpcBlockMergeResponseErrorCode int32

const (
	RpcBlockMergeResponseError_NULL          RpcBlockMergeResponseErrorCode = 0
	RpcBlockMergeResponseError_UNKNOWN_ERROR RpcBlockMergeResponseErrorCode = 1
	RpcBlockMergeResponseError_BAD_INPUT     RpcBlockMergeResponseErrorCode = 2
)

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

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

func (x RpcBlockMergeResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockMergeResponseErrorCode_name, int32(x))
}

func (RpcBlockMergeResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 3, 1, 0, 0}
}

type RpcBlockCopyResponseErrorCode int32

const (
	RpcBlockCopyResponseError_NULL          RpcBlockCopyResponseErrorCode = 0
	RpcBlockCopyResponseError_UNKNOWN_ERROR RpcBlockCopyResponseErrorCode = 1
	RpcBlockCopyResponseError_BAD_INPUT     RpcBlockCopyResponseErrorCode = 2
)

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

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

func (x RpcBlockCopyResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCopyResponseErrorCode_name, int32(x))
}

func (RpcBlockCopyResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 4, 1, 0, 0}
}

type RpcBlockPasteResponseErrorCode int32

const (
	RpcBlockPasteResponseError_NULL          RpcBlockPasteResponseErrorCode = 0
	RpcBlockPasteResponseError_UNKNOWN_ERROR RpcBlockPasteResponseErrorCode = 1
	RpcBlockPasteResponseError_BAD_INPUT     RpcBlockPasteResponseErrorCode = 2
)

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

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

func (x RpcBlockPasteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockPasteResponseErrorCode_name, int32(x))
}

func (RpcBlockPasteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 5, 1, 0, 0}
}

type RpcBlockCutResponseErrorCode int32

const (
	RpcBlockCutResponseError_NULL          RpcBlockCutResponseErrorCode = 0
	RpcBlockCutResponseError_UNKNOWN_ERROR RpcBlockCutResponseErrorCode = 1
	RpcBlockCutResponseError_BAD_INPUT     RpcBlockCutResponseErrorCode = 2
)

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

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

func (x RpcBlockCutResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCutResponseErrorCode_name, int32(x))
}

func (RpcBlockCutResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 6, 1, 0, 0}
}

type RpcBlockImportMarkdownResponseErrorCode int32

const (
	RpcBlockImportMarkdownResponseError_NULL          RpcBlockImportMarkdownResponseErrorCode = 0
	RpcBlockImportMarkdownResponseError_UNKNOWN_ERROR RpcBlockImportMarkdownResponseErrorCode = 1
	RpcBlockImportMarkdownResponseError_BAD_INPUT     RpcBlockImportMarkdownResponseErrorCode = 2
)

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

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

func (x RpcBlockImportMarkdownResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockImportMarkdownResponseErrorCode_name, int32(x))
}

func (RpcBlockImportMarkdownResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 7, 1, 0, 0}
}

type RpcBlockExportResponseErrorCode int32

const (
	RpcBlockExportResponseError_NULL          RpcBlockExportResponseErrorCode = 0
	RpcBlockExportResponseError_UNKNOWN_ERROR RpcBlockExportResponseErrorCode = 1
	RpcBlockExportResponseError_BAD_INPUT     RpcBlockExportResponseErrorCode = 2
)

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

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

func (x RpcBlockExportResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockExportResponseErrorCode_name, int32(x))
}

func (RpcBlockExportResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 8, 1, 0, 0}
}

type RpcBlockUploadResponseErrorCode int32

const (
	RpcBlockUploadResponseError_NULL          RpcBlockUploadResponseErrorCode = 0
	RpcBlockUploadResponseError_UNKNOWN_ERROR RpcBlockUploadResponseErrorCode = 1
	RpcBlockUploadResponseError_BAD_INPUT     RpcBlockUploadResponseErrorCode = 2
)

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

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

func (x RpcBlockUploadResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockUploadResponseErrorCode_name, int32(x))
}

func (RpcBlockUploadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 9, 1, 0, 0}
}

type RpcBlockDownloadResponseErrorCode int32

const (
	RpcBlockDownloadResponseError_NULL          RpcBlockDownloadResponseErrorCode = 0
	RpcBlockDownloadResponseError_UNKNOWN_ERROR RpcBlockDownloadResponseErrorCode = 1
	RpcBlockDownloadResponseError_BAD_INPUT     RpcBlockDownloadResponseErrorCode = 2
)

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

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

func (x RpcBlockDownloadResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDownloadResponseErrorCode_name, int32(x))
}

func (RpcBlockDownloadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 10, 1, 0, 0}
}

type RpcBlockSetFieldsResponseErrorCode int32

const (
	RpcBlockSetFieldsResponseError_NULL          RpcBlockSetFieldsResponseErrorCode = 0
	RpcBlockSetFieldsResponseError_UNKNOWN_ERROR RpcBlockSetFieldsResponseErrorCode = 1
	RpcBlockSetFieldsResponseError_BAD_INPUT     RpcBlockSetFieldsResponseErrorCode = 2
)

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

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

func (x RpcBlockSetFieldsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetFieldsResponseErrorCode_name, int32(x))
}

func (RpcBlockSetFieldsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 0, 1, 0, 0}
}

type RpcBlockSetDetailsResponseErrorCode int32

const (
	RpcBlockSetDetailsResponseError_NULL          RpcBlockSetDetailsResponseErrorCode = 0
	RpcBlockSetDetailsResponseError_UNKNOWN_ERROR RpcBlockSetDetailsResponseErrorCode = 1
	RpcBlockSetDetailsResponseError_BAD_INPUT     RpcBlockSetDetailsResponseErrorCode = 2
)

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

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

func (x RpcBlockSetDetailsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetDetailsResponseErrorCode_name, int32(x))
}

func (RpcBlockSetDetailsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 1, 2, 0, 0}
}

type RpcBlockSetRestrictionsResponseErrorCode int32

const (
	RpcBlockSetRestrictionsResponseError_NULL          RpcBlockSetRestrictionsResponseErrorCode = 0
	RpcBlockSetRestrictionsResponseError_UNKNOWN_ERROR RpcBlockSetRestrictionsResponseErrorCode = 1
	RpcBlockSetRestrictionsResponseError_BAD_INPUT     RpcBlockSetRestrictionsResponseErrorCode = 2
)

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

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

func (x RpcBlockSetRestrictionsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetRestrictionsResponseErrorCode_name, int32(x))
}

func (RpcBlockSetRestrictionsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 2, 1, 0, 0}
}

type RpcBlockSetPageIsArchivedResponseErrorCode int32

const (
	RpcBlockSetPageIsArchivedResponseError_NULL          RpcBlockSetPageIsArchivedResponseErrorCode = 0
	RpcBlockSetPageIsArchivedResponseError_UNKNOWN_ERROR RpcBlockSetPageIsArchivedResponseErrorCode = 1
	RpcBlockSetPageIsArchivedResponseError_BAD_INPUT     RpcBlockSetPageIsArchivedResponseErrorCode = 2
)

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

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

func (x RpcBlockSetPageIsArchivedResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetPageIsArchivedResponseErrorCode_name, int32(x))
}

func (RpcBlockSetPageIsArchivedResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 3, 0, 1, 0, 0}
}

type RpcBlockSetLatexTextResponseErrorCode int32

const (
	RpcBlockSetLatexTextResponseError_NULL          RpcBlockSetLatexTextResponseErrorCode = 0
	RpcBlockSetLatexTextResponseError_UNKNOWN_ERROR RpcBlockSetLatexTextResponseErrorCode = 1
	RpcBlockSetLatexTextResponseError_BAD_INPUT     RpcBlockSetLatexTextResponseErrorCode = 2
)

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

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

func (x RpcBlockSetLatexTextResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetLatexTextResponseErrorCode_name, int32(x))
}

func (RpcBlockSetLatexTextResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 4, 0, 1, 0, 0}
}

type RpcBlockSetTextTextResponseErrorCode int32

const (
	RpcBlockSetTextTextResponseError_NULL          RpcBlockSetTextTextResponseErrorCode = 0
	RpcBlockSetTextTextResponseError_UNKNOWN_ERROR RpcBlockSetTextTextResponseErrorCode = 1
	RpcBlockSetTextTextResponseError_BAD_INPUT     RpcBlockSetTextTextResponseErrorCode = 2
)

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

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

func (x RpcBlockSetTextTextResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetTextTextResponseErrorCode_name, int32(x))
}

func (RpcBlockSetTextTextResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 5, 0, 1, 0, 0}
}

type RpcBlockSetTextColorResponseErrorCode int32

const (
	RpcBlockSetTextColorResponseError_NULL          RpcBlockSetTextColorResponseErrorCode = 0
	RpcBlockSetTextColorResponseError_UNKNOWN_ERROR RpcBlockSetTextColorResponseErrorCode = 1
	RpcBlockSetTextColorResponseError_BAD_INPUT     RpcBlockSetTextColorResponseErrorCode = 2
)

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

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

func (x RpcBlockSetTextColorResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetTextColorResponseErrorCode_name, int32(x))
}

func (RpcBlockSetTextColorResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 5, 1, 1, 0, 0}
}

type RpcBlockSetTextStyleResponseErrorCode int32

const (
	RpcBlockSetTextStyleResponseError_NULL          RpcBlockSetTextStyleResponseErrorCode = 0
	RpcBlockSetTextStyleResponseError_UNKNOWN_ERROR RpcBlockSetTextStyleResponseErrorCode = 1
	RpcBlockSetTextStyleResponseError_BAD_INPUT     RpcBlockSetTextStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockSetTextStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetTextStyleResponseErrorCode_name, int32(x))
}

func (RpcBlockSetTextStyleResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 5, 2, 1, 0, 0}
}

type RpcBlockSetTextCheckedResponseErrorCode int32

const (
	RpcBlockSetTextCheckedResponseError_NULL          RpcBlockSetTextCheckedResponseErrorCode = 0
	RpcBlockSetTextCheckedResponseError_UNKNOWN_ERROR RpcBlockSetTextCheckedResponseErrorCode = 1
	RpcBlockSetTextCheckedResponseError_BAD_INPUT     RpcBlockSetTextCheckedResponseErrorCode = 2
)

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

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

func (x RpcBlockSetTextCheckedResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetTextCheckedResponseErrorCode_name, int32(x))
}

func (RpcBlockSetTextCheckedResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 5, 3, 1, 0, 0}
}

type RpcBlockSetTextIconResponseErrorCode int32

const (
	RpcBlockSetTextIconResponseError_NULL          RpcBlockSetTextIconResponseErrorCode = 0
	RpcBlockSetTextIconResponseError_UNKNOWN_ERROR RpcBlockSetTextIconResponseErrorCode = 1
	RpcBlockSetTextIconResponseError_BAD_INPUT     RpcBlockSetTextIconResponseErrorCode = 2
)

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

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

func (x RpcBlockSetTextIconResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetTextIconResponseErrorCode_name, int32(x))
}

func (RpcBlockSetTextIconResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 5, 4, 1, 0, 0}
}

type RpcBlockSetFileNameResponseErrorCode int32

const (
	RpcBlockSetFileNameResponseError_NULL          RpcBlockSetFileNameResponseErrorCode = 0
	RpcBlockSetFileNameResponseError_UNKNOWN_ERROR RpcBlockSetFileNameResponseErrorCode = 1
	RpcBlockSetFileNameResponseError_BAD_INPUT     RpcBlockSetFileNameResponseErrorCode = 2
)

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

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

func (x RpcBlockSetFileNameResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetFileNameResponseErrorCode_name, int32(x))
}

func (RpcBlockSetFileNameResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 6, 0, 1, 0, 0}
}

type RpcBlockSetImageNameResponseErrorCode int32

const (
	RpcBlockSetImageNameResponseError_NULL          RpcBlockSetImageNameResponseErrorCode = 0
	RpcBlockSetImageNameResponseError_UNKNOWN_ERROR RpcBlockSetImageNameResponseErrorCode = 1
	RpcBlockSetImageNameResponseError_BAD_INPUT     RpcBlockSetImageNameResponseErrorCode = 2
)

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

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

func (x RpcBlockSetImageNameResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetImageNameResponseErrorCode_name, int32(x))
}

func (RpcBlockSetImageNameResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 7, 0, 1, 0, 0}
}

type RpcBlockSetImageWidthResponseErrorCode int32

const (
	RpcBlockSetImageWidthResponseError_NULL          RpcBlockSetImageWidthResponseErrorCode = 0
	RpcBlockSetImageWidthResponseError_UNKNOWN_ERROR RpcBlockSetImageWidthResponseErrorCode = 1
	RpcBlockSetImageWidthResponseError_BAD_INPUT     RpcBlockSetImageWidthResponseErrorCode = 2
)

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

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

func (x RpcBlockSetImageWidthResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetImageWidthResponseErrorCode_name, int32(x))
}

func (RpcBlockSetImageWidthResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 7, 1, 1, 0, 0}
}

type RpcBlockSetVideoNameResponseErrorCode int32

const (
	RpcBlockSetVideoNameResponseError_NULL          RpcBlockSetVideoNameResponseErrorCode = 0
	RpcBlockSetVideoNameResponseError_UNKNOWN_ERROR RpcBlockSetVideoNameResponseErrorCode = 1
	RpcBlockSetVideoNameResponseError_BAD_INPUT     RpcBlockSetVideoNameResponseErrorCode = 2
)

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

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

func (x RpcBlockSetVideoNameResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetVideoNameResponseErrorCode_name, int32(x))
}

func (RpcBlockSetVideoNameResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 8, 0, 1, 0, 0}
}

type RpcBlockSetVideoWidthResponseErrorCode int32

const (
	RpcBlockSetVideoWidthResponseError_NULL          RpcBlockSetVideoWidthResponseErrorCode = 0
	RpcBlockSetVideoWidthResponseError_UNKNOWN_ERROR RpcBlockSetVideoWidthResponseErrorCode = 1
	RpcBlockSetVideoWidthResponseError_BAD_INPUT     RpcBlockSetVideoWidthResponseErrorCode = 2
)

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

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

func (x RpcBlockSetVideoWidthResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetVideoWidthResponseErrorCode_name, int32(x))
}

func (RpcBlockSetVideoWidthResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 8, 1, 1, 0, 0}
}

type RpcBlockSetLinkTargetBlockIdResponseErrorCode int32

const (
	RpcBlockSetLinkTargetBlockIdResponseError_NULL          RpcBlockSetLinkTargetBlockIdResponseErrorCode = 0
	RpcBlockSetLinkTargetBlockIdResponseError_UNKNOWN_ERROR RpcBlockSetLinkTargetBlockIdResponseErrorCode = 1
	RpcBlockSetLinkTargetBlockIdResponseError_BAD_INPUT     RpcBlockSetLinkTargetBlockIdResponseErrorCode = 2
)

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

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

func (x RpcBlockSetLinkTargetBlockIdResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetLinkTargetBlockIdResponseErrorCode_name, int32(x))
}

func (RpcBlockSetLinkTargetBlockIdResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 11, 9, 0, 1, 0, 0}
}

type RpcBlockRelationSetKeyResponseErrorCode int32

const (
	RpcBlockRelationSetKeyResponseError_NULL          RpcBlockRelationSetKeyResponseErrorCode = 0
	RpcBlockRelationSetKeyResponseError_UNKNOWN_ERROR RpcBlockRelationSetKeyResponseErrorCode = 1
	RpcBlockRelationSetKeyResponseError_BAD_INPUT     RpcBlockRelationSetKeyResponseErrorCode = 2
)

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

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

func (x RpcBlockRelationSetKeyResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockRelationSetKeyResponseErrorCode_name, int32(x))
}

func (RpcBlockRelationSetKeyResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 12, 0, 1, 0, 0}
}

type RpcBlockRelationAddResponseErrorCode int32

const (
	RpcBlockRelationAddResponseError_NULL          RpcBlockRelationAddResponseErrorCode = 0
	RpcBlockRelationAddResponseError_UNKNOWN_ERROR RpcBlockRelationAddResponseErrorCode = 1
	RpcBlockRelationAddResponseError_BAD_INPUT     RpcBlockRelationAddResponseErrorCode = 2
)

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

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

func (x RpcBlockRelationAddResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockRelationAddResponseErrorCode_name, int32(x))
}

func (RpcBlockRelationAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 12, 1, 1, 0, 0}
}

type RpcBlockObjectTypeSetResponseErrorCode int32

const (
	RpcBlockObjectTypeSetResponseError_NULL                    RpcBlockObjectTypeSetResponseErrorCode = 0
	RpcBlockObjectTypeSetResponseError_UNKNOWN_ERROR           RpcBlockObjectTypeSetResponseErrorCode = 1
	RpcBlockObjectTypeSetResponseError_BAD_INPUT               RpcBlockObjectTypeSetResponseErrorCode = 2
	RpcBlockObjectTypeSetResponseError_UNKNOWN_OBJECT_TYPE_URL RpcBlockObjectTypeSetResponseErrorCode = 3
)

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

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

func (x RpcBlockObjectTypeSetResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockObjectTypeSetResponseErrorCode_name, int32(x))
}

func (RpcBlockObjectTypeSetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 13, 0, 1, 0, 0}
}

type RpcBlockBookmarkFetchResponseErrorCode int32

const (
	RpcBlockBookmarkFetchResponseError_NULL          RpcBlockBookmarkFetchResponseErrorCode = 0
	RpcBlockBookmarkFetchResponseError_UNKNOWN_ERROR RpcBlockBookmarkFetchResponseErrorCode = 1
	RpcBlockBookmarkFetchResponseError_BAD_INPUT     RpcBlockBookmarkFetchResponseErrorCode = 2
)

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

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

func (x RpcBlockBookmarkFetchResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockBookmarkFetchResponseErrorCode_name, int32(x))
}

func (RpcBlockBookmarkFetchResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 14, 0, 1, 0, 0}
}

type RpcBlockBookmarkCreateAndFetchResponseErrorCode int32

const (
	RpcBlockBookmarkCreateAndFetchResponseError_NULL          RpcBlockBookmarkCreateAndFetchResponseErrorCode = 0
	RpcBlockBookmarkCreateAndFetchResponseError_UNKNOWN_ERROR RpcBlockBookmarkCreateAndFetchResponseErrorCode = 1
	RpcBlockBookmarkCreateAndFetchResponseError_BAD_INPUT     RpcBlockBookmarkCreateAndFetchResponseErrorCode = 2
)

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

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

func (x RpcBlockBookmarkCreateAndFetchResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockBookmarkCreateAndFetchResponseErrorCode_name, int32(x))
}

func (RpcBlockBookmarkCreateAndFetchResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 14, 1, 1, 0, 0}
}

type RpcBlockFileCreateAndUploadResponseErrorCode int32

const (
	RpcBlockFileCreateAndUploadResponseError_NULL          RpcBlockFileCreateAndUploadResponseErrorCode = 0
	RpcBlockFileCreateAndUploadResponseError_UNKNOWN_ERROR RpcBlockFileCreateAndUploadResponseErrorCode = 1
	RpcBlockFileCreateAndUploadResponseError_BAD_INPUT     RpcBlockFileCreateAndUploadResponseErrorCode = 2
)

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

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

func (x RpcBlockFileCreateAndUploadResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockFileCreateAndUploadResponseErrorCode_name, int32(x))
}

func (RpcBlockFileCreateAndUploadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 15, 0, 1, 0, 0}
}

type RpcBlockDataviewViewCreateResponseErrorCode int32

const (
	RpcBlockDataviewViewCreateResponseError_NULL          RpcBlockDataviewViewCreateResponseErrorCode = 0
	RpcBlockDataviewViewCreateResponseError_UNKNOWN_ERROR RpcBlockDataviewViewCreateResponseErrorCode = 1
	RpcBlockDataviewViewCreateResponseError_BAD_INPUT     RpcBlockDataviewViewCreateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewViewCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewViewCreateResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewViewCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 0, 1, 0, 0}
}

type RpcBlockDataviewViewUpdateResponseErrorCode int32

const (
	RpcBlockDataviewViewUpdateResponseError_NULL          RpcBlockDataviewViewUpdateResponseErrorCode = 0
	RpcBlockDataviewViewUpdateResponseError_UNKNOWN_ERROR RpcBlockDataviewViewUpdateResponseErrorCode = 1
	RpcBlockDataviewViewUpdateResponseError_BAD_INPUT     RpcBlockDataviewViewUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewViewUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewViewUpdateResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewViewUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 1, 1, 0, 0}
}

type RpcBlockDataviewViewDeleteResponseErrorCode int32

const (
	RpcBlockDataviewViewDeleteResponseError_NULL          RpcBlockDataviewViewDeleteResponseErrorCode = 0
	RpcBlockDataviewViewDeleteResponseError_UNKNOWN_ERROR RpcBlockDataviewViewDeleteResponseErrorCode = 1
	RpcBlockDataviewViewDeleteResponseError_BAD_INPUT     RpcBlockDataviewViewDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewViewDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewViewDeleteResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewViewDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 2, 1, 0, 0}
}

type RpcBlockDataviewViewSetPositionResponseErrorCode int32

const (
	RpcBlockDataviewViewSetPositionResponseError_NULL          RpcBlockDataviewViewSetPositionResponseErrorCode = 0
	RpcBlockDataviewViewSetPositionResponseError_UNKNOWN_ERROR RpcBlockDataviewViewSetPositionResponseErrorCode = 1
	RpcBlockDataviewViewSetPositionResponseError_BAD_INPUT     RpcBlockDataviewViewSetPositionResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewViewSetPositionResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewViewSetPositionResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewViewSetPositionResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 3, 1, 0, 0}
}

type RpcBlockDataviewViewSetActiveResponseErrorCode int32

const (
	RpcBlockDataviewViewSetActiveResponseError_NULL          RpcBlockDataviewViewSetActiveResponseErrorCode = 0
	RpcBlockDataviewViewSetActiveResponseError_UNKNOWN_ERROR RpcBlockDataviewViewSetActiveResponseErrorCode = 1
	RpcBlockDataviewViewSetActiveResponseError_BAD_INPUT     RpcBlockDataviewViewSetActiveResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewViewSetActiveResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewViewSetActiveResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewViewSetActiveResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 4, 1, 0, 0}
}

type RpcBlockDataviewRecordUpdateResponseErrorCode int32

const (
	RpcBlockDataviewRecordUpdateResponseError_NULL          RpcBlockDataviewRecordUpdateResponseErrorCode = 0
	RpcBlockDataviewRecordUpdateResponseError_UNKNOWN_ERROR RpcBlockDataviewRecordUpdateResponseErrorCode = 1
	RpcBlockDataviewRecordUpdateResponseError_BAD_INPUT     RpcBlockDataviewRecordUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRecordUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRecordUpdateResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRecordUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 5, 1, 0, 0}
}

type RpcBlockDataviewRecordDeleteResponseErrorCode int32

const (
	RpcBlockDataviewRecordDeleteResponseError_NULL          RpcBlockDataviewRecordDeleteResponseErrorCode = 0
	RpcBlockDataviewRecordDeleteResponseError_UNKNOWN_ERROR RpcBlockDataviewRecordDeleteResponseErrorCode = 1
	RpcBlockDataviewRecordDeleteResponseError_BAD_INPUT     RpcBlockDataviewRecordDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRecordDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRecordDeleteResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRecordDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 6, 1, 0, 0}
}

type RpcBlockDataviewRecordCreateResponseErrorCode int32

const (
	RpcBlockDataviewRecordCreateResponseError_NULL          RpcBlockDataviewRecordCreateResponseErrorCode = 0
	RpcBlockDataviewRecordCreateResponseError_UNKNOWN_ERROR RpcBlockDataviewRecordCreateResponseErrorCode = 1
	RpcBlockDataviewRecordCreateResponseError_BAD_INPUT     RpcBlockDataviewRecordCreateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRecordCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRecordCreateResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRecordCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 7, 1, 0, 0}
}

type RpcBlockDataviewRelationAddResponseErrorCode int32

const (
	RpcBlockDataviewRelationAddResponseError_NULL          RpcBlockDataviewRelationAddResponseErrorCode = 0
	RpcBlockDataviewRelationAddResponseError_UNKNOWN_ERROR RpcBlockDataviewRelationAddResponseErrorCode = 1
	RpcBlockDataviewRelationAddResponseError_BAD_INPUT     RpcBlockDataviewRelationAddResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRelationAddResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRelationAddResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRelationAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 8, 1, 0, 0}
}

type RpcBlockDataviewRelationUpdateResponseErrorCode int32

const (
	RpcBlockDataviewRelationUpdateResponseError_NULL          RpcBlockDataviewRelationUpdateResponseErrorCode = 0
	RpcBlockDataviewRelationUpdateResponseError_UNKNOWN_ERROR RpcBlockDataviewRelationUpdateResponseErrorCode = 1
	RpcBlockDataviewRelationUpdateResponseError_BAD_INPUT     RpcBlockDataviewRelationUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRelationUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRelationUpdateResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRelationUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 9, 1, 0, 0}
}

type RpcBlockDataviewRelationDeleteResponseErrorCode int32

const (
	RpcBlockDataviewRelationDeleteResponseError_NULL          RpcBlockDataviewRelationDeleteResponseErrorCode = 0
	RpcBlockDataviewRelationDeleteResponseError_UNKNOWN_ERROR RpcBlockDataviewRelationDeleteResponseErrorCode = 1
	RpcBlockDataviewRelationDeleteResponseError_BAD_INPUT     RpcBlockDataviewRelationDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRelationDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRelationDeleteResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRelationDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 10, 1, 0, 0}
}

type RpcBlockDataviewRecordRelationOptionAddResponseErrorCode int32

const (
	RpcBlockDataviewRecordRelationOptionAddResponseError_NULL          RpcBlockDataviewRecordRelationOptionAddResponseErrorCode = 0
	RpcBlockDataviewRecordRelationOptionAddResponseError_UNKNOWN_ERROR RpcBlockDataviewRecordRelationOptionAddResponseErrorCode = 1
	RpcBlockDataviewRecordRelationOptionAddResponseError_BAD_INPUT     RpcBlockDataviewRecordRelationOptionAddResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRecordRelationOptionAddResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRecordRelationOptionAddResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRecordRelationOptionAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 11, 1, 0, 0}
}

type RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode int32

const (
	RpcBlockDataviewRecordRelationOptionUpdateResponseError_NULL          RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode = 0
	RpcBlockDataviewRecordRelationOptionUpdateResponseError_UNKNOWN_ERROR RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode = 1
	RpcBlockDataviewRecordRelationOptionUpdateResponseError_BAD_INPUT     RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 12, 1, 0, 0}
}

type RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode int32

const (
	RpcBlockDataviewRecordRelationOptionDeleteResponseError_NULL          RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode = 0
	RpcBlockDataviewRecordRelationOptionDeleteResponseError_UNKNOWN_ERROR RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode = 1
	RpcBlockDataviewRecordRelationOptionDeleteResponseError_BAD_INPUT     RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 13, 1, 0, 0}
}

type RpcBlockDataviewRelationListAvailableResponseErrorCode int32

const (
	RpcBlockDataviewRelationListAvailableResponseError_NULL                 RpcBlockDataviewRelationListAvailableResponseErrorCode = 0
	RpcBlockDataviewRelationListAvailableResponseError_UNKNOWN_ERROR        RpcBlockDataviewRelationListAvailableResponseErrorCode = 1
	RpcBlockDataviewRelationListAvailableResponseError_BAD_INPUT            RpcBlockDataviewRelationListAvailableResponseErrorCode = 2
	RpcBlockDataviewRelationListAvailableResponseError_NOT_A_DATAVIEW_BLOCK RpcBlockDataviewRelationListAvailableResponseErrorCode = 3
)

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

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

func (x RpcBlockDataviewRelationListAvailableResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewRelationListAvailableResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewRelationListAvailableResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 14, 1, 0, 0}
}

type RpcBlockDataviewSetSourceResponseErrorCode int32

const (
	RpcBlockDataviewSetSourceResponseError_NULL          RpcBlockDataviewSetSourceResponseErrorCode = 0
	RpcBlockDataviewSetSourceResponseError_UNKNOWN_ERROR RpcBlockDataviewSetSourceResponseErrorCode = 1
	RpcBlockDataviewSetSourceResponseError_BAD_INPUT     RpcBlockDataviewSetSourceResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewSetSourceResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewSetSourceResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewSetSourceResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 15, 1, 0, 0}
}

type RpcBlockGetMarksResponseErrorCode int32

const (
	RpcBlockGetMarksResponseError_NULL          RpcBlockGetMarksResponseErrorCode = 0
	RpcBlockGetMarksResponseError_UNKNOWN_ERROR RpcBlockGetMarksResponseErrorCode = 1
	RpcBlockGetMarksResponseError_BAD_INPUT     RpcBlockGetMarksResponseErrorCode = 2
)

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

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

func (x RpcBlockGetMarksResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockGetMarksResponseErrorCode_name, int32(x))
}

func (RpcBlockGetMarksResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 17, 0, 1, 0, 0}
}

type RpcBlockUndoResponseErrorCode int32

const (
	RpcBlockUndoResponseError_NULL          RpcBlockUndoResponseErrorCode = 0
	RpcBlockUndoResponseError_UNKNOWN_ERROR RpcBlockUndoResponseErrorCode = 1
	RpcBlockUndoResponseError_BAD_INPUT     RpcBlockUndoResponseErrorCode = 2
	RpcBlockUndoResponseError_CAN_NOT_MOVE  RpcBlockUndoResponseErrorCode = 3
)

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

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

func (x RpcBlockUndoResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockUndoResponseErrorCode_name, int32(x))
}

func (RpcBlockUndoResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 19, 1, 0, 0}
}

type RpcBlockRedoResponseErrorCode int32

const (
	RpcBlockRedoResponseError_NULL          RpcBlockRedoResponseErrorCode = 0
	RpcBlockRedoResponseError_UNKNOWN_ERROR RpcBlockRedoResponseErrorCode = 1
	RpcBlockRedoResponseError_BAD_INPUT     RpcBlockRedoResponseErrorCode = 2
	RpcBlockRedoResponseError_CAN_NOT_MOVE  RpcBlockRedoResponseErrorCode = 3
)

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

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

func (x RpcBlockRedoResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockRedoResponseErrorCode_name, int32(x))
}

func (RpcBlockRedoResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 20, 1, 0, 0}
}

type RpcBlockOpenResponseErrorCode int32

const (
	RpcBlockOpenResponseError_NULL                  RpcBlockOpenResponseErrorCode = 0
	RpcBlockOpenResponseError_UNKNOWN_ERROR         RpcBlockOpenResponseErrorCode = 1
	RpcBlockOpenResponseError_BAD_INPUT             RpcBlockOpenResponseErrorCode = 2
	RpcBlockOpenResponseError_NOT_FOUND             RpcBlockOpenResponseErrorCode = 3
	RpcBlockOpenResponseError_ANYTYPE_NEEDS_UPGRADE RpcBlockOpenResponseErrorCode = 10
)

var RpcBlockOpenResponseErrorCode_name = map[int32]string{
	0:  "NULL",
	1:  "UNKNOWN_ERROR",
	2:  "BAD_INPUT",
	3:  "NOT_FOUND",
	10: "ANYTYPE_NEEDS_UPGRADE",
}

var RpcBlockOpenResponseErrorCode_value = map[string]int32{
	"NULL":                  0,
	"UNKNOWN_ERROR":         1,
	"BAD_INPUT":             2,
	"NOT_FOUND":             3,
	"ANYTYPE_NEEDS_UPGRADE": 10,
}

func (x RpcBlockOpenResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockOpenResponseErrorCode_name, int32(x))
}

func (RpcBlockOpenResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 21, 1, 0, 0}
}

type RpcBlockShowResponseErrorCode int32

const (
	RpcBlockShowResponseError_NULL                  RpcBlockShowResponseErrorCode = 0
	RpcBlockShowResponseError_UNKNOWN_ERROR         RpcBlockShowResponseErrorCode = 1
	RpcBlockShowResponseError_BAD_INPUT             RpcBlockShowResponseErrorCode = 2
	RpcBlockShowResponseError_NOT_FOUND             RpcBlockShowResponseErrorCode = 3
	RpcBlockShowResponseError_ANYTYPE_NEEDS_UPGRADE RpcBlockShowResponseErrorCode = 10
)

var RpcBlockShowResponseErrorCode_name = map[int32]string{
	0:  "NULL",
	1:  "UNKNOWN_ERROR",
	2:  "BAD_INPUT",
	3:  "NOT_FOUND",
	10: "ANYTYPE_NEEDS_UPGRADE",
}

var RpcBlockShowResponseErrorCode_value = map[string]int32{
	"NULL":                  0,
	"UNKNOWN_ERROR":         1,
	"BAD_INPUT":             2,
	"NOT_FOUND":             3,
	"ANYTYPE_NEEDS_UPGRADE": 10,
}

func (x RpcBlockShowResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockShowResponseErrorCode_name, int32(x))
}

func (RpcBlockShowResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 22, 1, 0, 0}
}

type RpcBlockGetPublicWebURLResponseErrorCode int32

const (
	RpcBlockGetPublicWebURLResponseError_NULL          RpcBlockGetPublicWebURLResponseErrorCode = 0
	RpcBlockGetPublicWebURLResponseError_UNKNOWN_ERROR RpcBlockGetPublicWebURLResponseErrorCode = 1
	RpcBlockGetPublicWebURLResponseError_BAD_INPUT     RpcBlockGetPublicWebURLResponseErrorCode = 2
)

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

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

func (x RpcBlockGetPublicWebURLResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockGetPublicWebURLResponseErrorCode_name, int32(x))
}

func (RpcBlockGetPublicWebURLResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 23, 1, 0, 0}
}

type RpcBlockOpenBreadcrumbsResponseErrorCode int32

const (
	RpcBlockOpenBreadcrumbsResponseError_NULL          RpcBlockOpenBreadcrumbsResponseErrorCode = 0
	RpcBlockOpenBreadcrumbsResponseError_UNKNOWN_ERROR RpcBlockOpenBreadcrumbsResponseErrorCode = 1
	RpcBlockOpenBreadcrumbsResponseError_BAD_INPUT     RpcBlockOpenBreadcrumbsResponseErrorCode = 2
)

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

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

func (x RpcBlockOpenBreadcrumbsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockOpenBreadcrumbsResponseErrorCode_name, int32(x))
}

func (RpcBlockOpenBreadcrumbsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 24, 1, 0, 0}
}

type RpcBlockSetBreadcrumbsResponseErrorCode int32

const (
	RpcBlockSetBreadcrumbsResponseError_NULL          RpcBlockSetBreadcrumbsResponseErrorCode = 0
	RpcBlockSetBreadcrumbsResponseError_UNKNOWN_ERROR RpcBlockSetBreadcrumbsResponseErrorCode = 1
	RpcBlockSetBreadcrumbsResponseError_BAD_INPUT     RpcBlockSetBreadcrumbsResponseErrorCode = 2
)

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

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

func (x RpcBlockSetBreadcrumbsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockSetBreadcrumbsResponseErrorCode_name, int32(x))
}

func (RpcBlockSetBreadcrumbsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 25, 1, 0, 0}
}

type RpcBlockCreateResponseErrorCode int32

const (
	RpcBlockCreateResponseError_NULL          RpcBlockCreateResponseErrorCode = 0
	RpcBlockCreateResponseError_UNKNOWN_ERROR RpcBlockCreateResponseErrorCode = 1
	RpcBlockCreateResponseError_BAD_INPUT     RpcBlockCreateResponseErrorCode = 2
)

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

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

func (x RpcBlockCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCreateResponseErrorCode_name, int32(x))
}

func (RpcBlockCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 26, 1, 0, 0}
}

type RpcBlockCreatePageResponseErrorCode int32

const (
	RpcBlockCreatePageResponseError_NULL          RpcBlockCreatePageResponseErrorCode = 0
	RpcBlockCreatePageResponseError_UNKNOWN_ERROR RpcBlockCreatePageResponseErrorCode = 1
	RpcBlockCreatePageResponseError_BAD_INPUT     RpcBlockCreatePageResponseErrorCode = 2
)

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

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

func (x RpcBlockCreatePageResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCreatePageResponseErrorCode_name, int32(x))
}

func (RpcBlockCreatePageResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 27, 1, 0, 0}
}

type RpcBlockCreateSetResponseErrorCode int32

const (
	RpcBlockCreateSetResponseError_NULL                    RpcBlockCreateSetResponseErrorCode = 0
	RpcBlockCreateSetResponseError_UNKNOWN_ERROR           RpcBlockCreateSetResponseErrorCode = 1
	RpcBlockCreateSetResponseError_BAD_INPUT               RpcBlockCreateSetResponseErrorCode = 2
	RpcBlockCreateSetResponseError_UNKNOWN_OBJECT_TYPE_URL RpcBlockCreateSetResponseErrorCode = 3
)

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

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

func (x RpcBlockCreateSetResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCreateSetResponseErrorCode_name, int32(x))
}

func (RpcBlockCreateSetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 28, 1, 0, 0}
}

type RpcBlockUnlinkResponseErrorCode int32

const (
	RpcBlockUnlinkResponseError_NULL          RpcBlockUnlinkResponseErrorCode = 0
	RpcBlockUnlinkResponseError_UNKNOWN_ERROR RpcBlockUnlinkResponseErrorCode = 1
	RpcBlockUnlinkResponseError_BAD_INPUT     RpcBlockUnlinkResponseErrorCode = 2
)

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

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

func (x RpcBlockUnlinkResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockUnlinkResponseErrorCode_name, int32(x))
}

func (RpcBlockUnlinkResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 29, 1, 0, 0}
}

type RpcBlockCloseResponseErrorCode int32

const (
	RpcBlockCloseResponseError_NULL          RpcBlockCloseResponseErrorCode = 0
	RpcBlockCloseResponseError_UNKNOWN_ERROR RpcBlockCloseResponseErrorCode = 1
	RpcBlockCloseResponseError_BAD_INPUT     RpcBlockCloseResponseErrorCode = 2
)

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

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

func (x RpcBlockCloseResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCloseResponseErrorCode_name, int32(x))
}

func (RpcBlockCloseResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 30, 1, 0, 0}
}

type RpcWorkspaceGetCurrentResponseErrorCode int32

const (
	RpcWorkspaceGetCurrentResponseError_NULL          RpcWorkspaceGetCurrentResponseErrorCode = 0
	RpcWorkspaceGetCurrentResponseError_UNKNOWN_ERROR RpcWorkspaceGetCurrentResponseErrorCode = 1
	RpcWorkspaceGetCurrentResponseError_BAD_INPUT     RpcWorkspaceGetCurrentResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceGetCurrentResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceGetCurrentResponseErrorCode_name, int32(x))
}

func (RpcWorkspaceGetCurrentResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 0, 1, 0, 0}
}

type RpcWorkspaceGetAllResponseErrorCode int32

const (
	RpcWorkspaceGetAllResponseError_NULL          RpcWorkspaceGetAllResponseErrorCode = 0
	RpcWorkspaceGetAllResponseError_UNKNOWN_ERROR RpcWorkspaceGetAllResponseErrorCode = 1
	RpcWorkspaceGetAllResponseError_BAD_INPUT     RpcWorkspaceGetAllResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceGetAllResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceGetAllResponseErrorCode_name, int32(x))
}

func (RpcWorkspaceGetAllResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 1, 1, 0, 0}
}

type RpcWorkspaceCreateResponseErrorCode int32

const (
	RpcWorkspaceCreateResponseError_NULL          RpcWorkspaceCreateResponseErrorCode = 0
	RpcWorkspaceCreateResponseError_UNKNOWN_ERROR RpcWorkspaceCreateResponseErrorCode = 1
	RpcWorkspaceCreateResponseError_BAD_INPUT     RpcWorkspaceCreateResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceCreateResponseErrorCode_name, int32(x))
}

func (RpcWorkspaceCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 2, 1, 0, 0}
}

type RpcWorkspaceSetIsHighlightedResponseErrorCode int32

const (
	RpcWorkspaceSetIsHighlightedResponseError_NULL          RpcWorkspaceSetIsHighlightedResponseErrorCode = 0
	RpcWorkspaceSetIsHighlightedResponseError_UNKNOWN_ERROR RpcWorkspaceSetIsHighlightedResponseErrorCode = 1
	RpcWorkspaceSetIsHighlightedResponseError_BAD_INPUT     RpcWorkspaceSetIsHighlightedResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceSetIsHighlightedResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceSetIsHighlightedResponseErrorCode_name, int32(x))
}

func (RpcWorkspaceSetIsHighlightedResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 3, 1, 0, 0}
}

type RpcWorkspaceSelectResponseErrorCode int32

const (
	RpcWorkspaceSelectResponseError_NULL          RpcWorkspaceSelectResponseErrorCode = 0
	RpcWorkspaceSelectResponseError_UNKNOWN_ERROR RpcWorkspaceSelectResponseErrorCode = 1
	RpcWorkspaceSelectResponseError_BAD_INPUT     RpcWorkspaceSelectResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceSelectResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceSelectResponseErrorCode_name, int32(x))
}

func (RpcWorkspaceSelectResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 4, 1, 0, 0}
}

type RpcWalletCreateResponseErrorCode int32

const (
	RpcWalletCreateResponseError_NULL                        RpcWalletCreateResponseErrorCode = 0
	RpcWalletCreateResponseError_UNKNOWN_ERROR               RpcWalletCreateResponseErrorCode = 1
	RpcWalletCreateResponseError_BAD_INPUT                   RpcWalletCreateResponseErrorCode = 2
	RpcWalletCreateResponseError_FAILED_TO_CREATE_LOCAL_REPO RpcWalletCreateResponseErrorCode = 101
)

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

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

func (x RpcWalletCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcWalletCreateResponseErrorCode_name, int32(x))
}

func (RpcWalletCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 0, 1, 0, 0}
}

type RpcWalletRecoverResponseErrorCode int32

const (
	RpcWalletRecoverResponseError_NULL                        RpcWalletRecoverResponseErrorCode = 0
	RpcWalletRecoverResponseError_UNKNOWN_ERROR               RpcWalletRecoverResponseErrorCode = 1
	RpcWalletRecoverResponseError_BAD_INPUT                   RpcWalletRecoverResponseErrorCode = 2
	RpcWalletRecoverResponseError_FAILED_TO_CREATE_LOCAL_REPO RpcWalletRecoverResponseErrorCode = 101
)

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

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

func (x RpcWalletRecoverResponseErrorCode) String() string {
	return proto.EnumName(RpcWalletRecoverResponseErrorCode_name, int32(x))
}

func (RpcWalletRecoverResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 1, 1, 0, 0}
}

type RpcWalletConvertResponseErrorCode int32

const (
	RpcWalletConvertResponseError_NULL          RpcWalletConvertResponseErrorCode = 0
	RpcWalletConvertResponseError_UNKNOWN_ERROR RpcWalletConvertResponseErrorCode = 1
	RpcWalletConvertResponseError_BAD_INPUT     RpcWalletConvertResponseErrorCode = 2
)

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

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

func (x RpcWalletConvertResponseErrorCode) String() string {
	return proto.EnumName(RpcWalletConvertResponseErrorCode_name, int32(x))
}

func (RpcWalletConvertResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 2, 1, 0, 0}
}

type RpcAccountCreateResponseErrorCode int32

const (
	RpcAccountCreateResponseError_NULL                                     RpcAccountCreateResponseErrorCode = 0
	RpcAccountCreateResponseError_UNKNOWN_ERROR                            RpcAccountCreateResponseErrorCode = 1
	RpcAccountCreateResponseError_BAD_INPUT                                RpcAccountCreateResponseErrorCode = 2
	RpcAccountCreateResponseError_ACCOUNT_CREATED_BUT_FAILED_TO_START_NODE RpcAccountCreateResponseErrorCode = 101
	RpcAccountCreateResponseError_ACCOUNT_CREATED_BUT_FAILED_TO_SET_NAME   RpcAccountCreateResponseErrorCode = 102
	RpcAccountCreateResponseError_ACCOUNT_CREATED_BUT_FAILED_TO_SET_AVATAR RpcAccountCreateResponseErrorCode = 103
	RpcAccountCreateResponseError_FAILED_TO_STOP_RUNNING_NODE              RpcAccountCreateResponseErrorCode = 104
	RpcAccountCreateResponseError_BAD_INVITE_CODE                          RpcAccountCreateResponseErrorCode = 900
	RpcAccountCreateResponseError_NET_ERROR                                RpcAccountCreateResponseErrorCode = 901
	RpcAccountCreateResponseError_NET_CONNECTION_REFUSED                   RpcAccountCreateResponseErrorCode = 902
	RpcAccountCreateResponseError_NET_OFFLINE                              RpcAccountCreateResponseErrorCode = 903
)

var RpcAccountCreateResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "ACCOUNT_CREATED_BUT_FAILED_TO_START_NODE",
	102: "ACCOUNT_CREATED_BUT_FAILED_TO_SET_NAME",
	103: "ACCOUNT_CREATED_BUT_FAILED_TO_SET_AVATAR",
	104: "FAILED_TO_STOP_RUNNING_NODE",
	900: "BAD_INVITE_CODE",
	901: "NET_ERROR",
	902: "NET_CONNECTION_REFUSED",
	903: "NET_OFFLINE",
}

var RpcAccountCreateResponseErrorCode_value = map[string]int32{
	"NULL":          0,
	"UNKNOWN_ERROR": 1,
	"BAD_INPUT":     2,
	"ACCOUNT_CREATED_BUT_FAILED_TO_START_NODE": 101,
	"ACCOUNT_CREATED_BUT_FAILED_TO_SET_NAME":   102,
	"ACCOUNT_CREATED_BUT_FAILED_TO_SET_AVATAR": 103,
	"FAILED_TO_STOP_RUNNING_NODE":              104,
	"BAD_INVITE_CODE":                          900,
	"NET_ERROR":                                901,
	"NET_CONNECTION_REFUSED":                   902,
	"NET_OFFLINE":                              903,
}

func (x RpcAccountCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountCreateResponseErrorCode_name, int32(x))
}

func (RpcAccountCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 1, 1, 0, 0}
}

type RpcAccountRecoverResponseErrorCode int32

const (
	RpcAccountRecoverResponseError_NULL                               RpcAccountRecoverResponseErrorCode = 0
	RpcAccountRecoverResponseError_UNKNOWN_ERROR                      RpcAccountRecoverResponseErrorCode = 1
	RpcAccountRecoverResponseError_BAD_INPUT                          RpcAccountRecoverResponseErrorCode = 2
	RpcAccountRecoverResponseError_NO_ACCOUNTS_FOUND                  RpcAccountRecoverResponseErrorCode = 101
	RpcAccountRecoverResponseError_NEED_TO_RECOVER_WALLET_FIRST       RpcAccountRecoverResponseErrorCode = 102
	RpcAccountRecoverResponseError_FAILED_TO_CREATE_LOCAL_REPO        RpcAccountRecoverResponseErrorCode = 103
	RpcAccountRecoverResponseError_LOCAL_REPO_EXISTS_BUT_CORRUPTED    RpcAccountRecoverResponseErrorCode = 104
	RpcAccountRecoverResponseError_FAILED_TO_RUN_NODE                 RpcAccountRecoverResponseErrorCode = 105
	RpcAccountRecoverResponseError_WALLET_RECOVER_NOT_PERFORMED       RpcAccountRecoverResponseErrorCode = 106
	RpcAccountRecoverResponseError_FAILED_TO_STOP_RUNNING_NODE        RpcAccountRecoverResponseErrorCode = 107
	RpcAccountRecoverResponseError_ANOTHER_ANYTYPE_PROCESS_IS_RUNNING RpcAccountRecoverResponseErrorCode = 108
)

var RpcAccountRecoverResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "NO_ACCOUNTS_FOUND",
	102: "NEED_TO_RECOVER_WALLET_FIRST",
	103: "FAILED_TO_CREATE_LOCAL_REPO",
	104: "LOCAL_REPO_EXISTS_BUT_CORRUPTED",
	105: "FAILED_TO_RUN_NODE",
	106: "WALLET_RECOVER_NOT_PERFORMED",
	107: "FAILED_TO_STOP_RUNNING_NODE",
	108: "ANOTHER_ANYTYPE_PROCESS_IS_RUNNING",
}

var RpcAccountRecoverResponseErrorCode_value = map[string]int32{
	"NULL":                               0,
	"UNKNOWN_ERROR":                      1,
	"BAD_INPUT":                          2,
	"NO_ACCOUNTS_FOUND":                  101,
	"NEED_TO_RECOVER_WALLET_FIRST":       102,
	"FAILED_TO_CREATE_LOCAL_REPO":        103,
	"LOCAL_REPO_EXISTS_BUT_CORRUPTED":    104,
	"FAILED_TO_RUN_NODE":                 105,
	"WALLET_RECOVER_NOT_PERFORMED":       106,
	"FAILED_TO_STOP_RUNNING_NODE":        107,
	"ANOTHER_ANYTYPE_PROCESS_IS_RUNNING": 108,
}

func (x RpcAccountRecoverResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountRecoverResponseErrorCode_name, int32(x))
}

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

type RpcAccountSelectResponseErrorCode int32

const (
	RpcAccountSelectResponseError_NULL                                       RpcAccountSelectResponseErrorCode = 0
	RpcAccountSelectResponseError_UNKNOWN_ERROR                              RpcAccountSelectResponseErrorCode = 1
	RpcAccountSelectResponseError_BAD_INPUT                                  RpcAccountSelectResponseErrorCode = 2
	RpcAccountSelectResponseError_FAILED_TO_CREATE_LOCAL_REPO                RpcAccountSelectResponseErrorCode = 101
	RpcAccountSelectResponseError_LOCAL_REPO_EXISTS_BUT_CORRUPTED            RpcAccountSelectResponseErrorCode = 102
	RpcAccountSelectResponseError_FAILED_TO_RUN_NODE                         RpcAccountSelectResponseErrorCode = 103
	RpcAccountSelectResponseError_FAILED_TO_FIND_ACCOUNT_INFO                RpcAccountSelectResponseErrorCode = 104
	RpcAccountSelectResponseError_LOCAL_REPO_NOT_EXISTS_AND_MNEMONIC_NOT_SET RpcAccountSelectResponseErrorCode = 105
	RpcAccountSelectResponseError_FAILED_TO_STOP_SEARCHER_NODE               RpcAccountSelectResponseErrorCode = 106
	RpcAccountSelectResponseError_FAILED_TO_RECOVER_PREDEFINED_BLOCKS        RpcAccountSelectResponseErrorCode = 107
	RpcAccountSelectResponseError_ANOTHER_ANYTYPE_PROCESS_IS_RUNNING         RpcAccountSelectResponseErrorCode = 108
)

var RpcAccountSelectResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "FAILED_TO_CREATE_LOCAL_REPO",
	102: "LOCAL_REPO_EXISTS_BUT_CORRUPTED",
	103: "FAILED_TO_RUN_NODE",
	104: "FAILED_TO_FIND_ACCOUNT_INFO",
	105: "LOCAL_REPO_NOT_EXISTS_AND_MNEMONIC_NOT_SET",
	106: "FAILED_TO_STOP_SEARCHER_NODE",
	107: "FAILED_TO_RECOVER_PREDEFINED_BLOCKS",
	108: "ANOTHER_ANYTYPE_PROCESS_IS_RUNNING",
}

var RpcAccountSelectResponseErrorCode_value = map[string]int32{
	"NULL":                                       0,
	"UNKNOWN_ERROR":                              1,
	"BAD_INPUT":                                  2,
	"FAILED_TO_CREATE_LOCAL_REPO":                101,
	"LOCAL_REPO_EXISTS_BUT_CORRUPTED":            102,
	"FAILED_TO_RUN_NODE":                         103,
	"FAILED_TO_FIND_ACCOUNT_INFO":                104,
	"LOCAL_REPO_NOT_EXISTS_AND_MNEMONIC_NOT_SET": 105,
	"FAILED_TO_STOP_SEARCHER_NODE":               106,
	"FAILED_TO_RECOVER_PREDEFINED_BLOCKS":        107,
	"ANOTHER_ANYTYPE_PROCESS_IS_RUNNING":         108,
}

func (x RpcAccountSelectResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountSelectResponseErrorCode_name, int32(x))
}

func (RpcAccountSelectResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 3, 1, 0, 0}
}

type RpcAccountStopResponseErrorCode int32

const (
	RpcAccountStopResponseError_NULL                          RpcAccountStopResponseErrorCode = 0
	RpcAccountStopResponseError_UNKNOWN_ERROR                 RpcAccountStopResponseErrorCode = 1
	RpcAccountStopResponseError_BAD_INPUT                     RpcAccountStopResponseErrorCode = 2
	RpcAccountStopResponseError_ACCOUNT_IS_NOT_RUNNING        RpcAccountStopResponseErrorCode = 101
	RpcAccountStopResponseError_FAILED_TO_STOP_NODE           RpcAccountStopResponseErrorCode = 102
	RpcAccountStopResponseError_FAILED_TO_REMOVE_ACCOUNT_DATA RpcAccountStopResponseErrorCode = 103
)

var RpcAccountStopResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "ACCOUNT_IS_NOT_RUNNING",
	102: "FAILED_TO_STOP_NODE",
	103: "FAILED_TO_REMOVE_ACCOUNT_DATA",
}

var RpcAccountStopResponseErrorCode_value = map[string]int32{
	"NULL":                          0,
	"UNKNOWN_ERROR":                 1,
	"BAD_INPUT":                     2,
	"ACCOUNT_IS_NOT_RUNNING":        101,
	"FAILED_TO_STOP_NODE":           102,
	"FAILED_TO_REMOVE_ACCOUNT_DATA": 103,
}

func (x RpcAccountStopResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountStopResponseErrorCode_name, int32(x))
}

func (RpcAccountStopResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 4, 1, 0, 0}
}

type RpcLogSendRequestLevel int32

const (
	RpcLogSendRequest_DEBUG   RpcLogSendRequestLevel = 0
	RpcLogSendRequest_ERROR   RpcLogSendRequestLevel = 1
	RpcLogSendRequest_FATAL   RpcLogSendRequestLevel = 2
	RpcLogSendRequest_INFO    RpcLogSendRequestLevel = 3
	RpcLogSendRequest_PANIC   RpcLogSendRequestLevel = 4
	RpcLogSendRequest_WARNING RpcLogSendRequestLevel = 5
)

var RpcLogSendRequestLevel_name = map[int32]string{
	0: "DEBUG",
	1: "ERROR",
	2: "FATAL",
	3: "INFO",
	4: "PANIC",
	5: "WARNING",
}

var RpcLogSendRequestLevel_value = map[string]int32{
	"DEBUG":   0,
	"ERROR":   1,
	"FATAL":   2,
	"INFO":    3,
	"PANIC":   4,
	"WARNING": 5,
}

func (x RpcLogSendRequestLevel) String() string {
	return proto.EnumName(RpcLogSendRequestLevel_name, int32(x))
}

func (RpcLogSendRequestLevel) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7, 0, 0, 0}
}

type RpcLogSendResponseErrorCode int32

const (
	RpcLogSendResponseError_NULL          RpcLogSendResponseErrorCode = 0
	RpcLogSendResponseError_UNKNOWN_ERROR RpcLogSendResponseErrorCode = 1
	RpcLogSendResponseError_BAD_INPUT     RpcLogSendResponseErrorCode = 2
	RpcLogSendResponseError_NOT_FOUND     RpcLogSendResponseErrorCode = 101
	RpcLogSendResponseError_TIMEOUT       RpcLogSendResponseErrorCode = 102
)

var RpcLogSendResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "NOT_FOUND",
	102: "TIMEOUT",
}

var RpcLogSendResponseErrorCode_value = map[string]int32{
	"NULL":          0,
	"UNKNOWN_ERROR": 1,
	"BAD_INPUT":     2,
	"NOT_FOUND":     101,
	"TIMEOUT":       102,
}

func (x RpcLogSendResponseErrorCode) String() string {
	return proto.EnumName(RpcLogSendResponseErrorCode_name, int32(x))
}

func (RpcLogSendResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7, 0, 1, 0, 0}
}

type RpcVersionGetResponseErrorCode int32

const (
	RpcVersionGetResponseError_NULL             RpcVersionGetResponseErrorCode = 0
	RpcVersionGetResponseError_UNKNOWN_ERROR    RpcVersionGetResponseErrorCode = 1
	RpcVersionGetResponseError_BAD_INPUT        RpcVersionGetResponseErrorCode = 2
	RpcVersionGetResponseError_VERSION_IS_EMPTY RpcVersionGetResponseErrorCode = 3
	RpcVersionGetResponseError_NOT_FOUND        RpcVersionGetResponseErrorCode = 101
	RpcVersionGetResponseError_TIMEOUT          RpcVersionGetResponseErrorCode = 102
)

var RpcVersionGetResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	3:   "VERSION_IS_EMPTY",
	101: "NOT_FOUND",
	102: "TIMEOUT",
}

var RpcVersionGetResponseErrorCode_value = map[string]int32{
	"NULL":             0,
	"UNKNOWN_ERROR":    1,
	"BAD_INPUT":        2,
	"VERSION_IS_EMPTY": 3,
	"NOT_FOUND":        101,
	"TIMEOUT":          102,
}

func (x RpcVersionGetResponseErrorCode) String() string {
	return proto.EnumName(RpcVersionGetResponseErrorCode_name, int32(x))
}

func (RpcVersionGetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 0, 1, 0, 0}
}

type RpcFileOffloadResponseErrorCode int32

const (
	RpcFileOffloadResponseError_NULL          RpcFileOffloadResponseErrorCode = 0
	RpcFileOffloadResponseError_UNKNOWN_ERROR RpcFileOffloadResponseErrorCode = 1
	RpcFileOffloadResponseError_BAD_INPUT     RpcFileOffloadResponseErrorCode = 2
	// ...
	RpcFileOffloadResponseError_NODE_NOT_STARTED    RpcFileOffloadResponseErrorCode = 103
	RpcFileOffloadResponseError_FILE_NOT_YET_PINNED RpcFileOffloadResponseErrorCode = 104
)

var RpcFileOffloadResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	103: "NODE_NOT_STARTED",
	104: "FILE_NOT_YET_PINNED",
}

var RpcFileOffloadResponseErrorCode_value = map[string]int32{
	"NULL":                0,
	"UNKNOWN_ERROR":       1,
	"BAD_INPUT":           2,
	"NODE_NOT_STARTED":    103,
	"FILE_NOT_YET_PINNED": 104,
}

func (x RpcFileOffloadResponseErrorCode) String() string {
	return proto.EnumName(RpcFileOffloadResponseErrorCode_name, int32(x))
}

func (RpcFileOffloadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 0, 1, 0, 0}
}

type RpcFileListOffloadResponseErrorCode int32

const (
	RpcFileListOffloadResponseError_NULL          RpcFileListOffloadResponseErrorCode = 0
	RpcFileListOffloadResponseError_UNKNOWN_ERROR RpcFileListOffloadResponseErrorCode = 1
	RpcFileListOffloadResponseError_BAD_INPUT     RpcFileListOffloadResponseErrorCode = 2
	// ...
	RpcFileListOffloadResponseError_NODE_NOT_STARTED RpcFileListOffloadResponseErrorCode = 103
)

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

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

func (x RpcFileListOffloadResponseErrorCode) String() string {
	return proto.EnumName(RpcFileListOffloadResponseErrorCode_name, int32(x))
}

func (RpcFileListOffloadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 10, 0, 1, 0, 0}
}

type RpcShutdownResponseErrorCode int32

const (
	RpcShutdownResponseError_NULL             RpcShutdownResponseErrorCode = 0
	RpcShutdownResponseError_UNKNOWN_ERROR    RpcShutdownResponseErrorCode = 1
	RpcShutdownResponseError_BAD_INPUT        RpcShutdownResponseErrorCode = 2
	RpcShutdownResponseError_NODE_NOT_STARTED RpcShutdownResponseErrorCode = 101
)

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

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

func (x RpcShutdownResponseErrorCode) String() string {
	return proto.EnumName(RpcShutdownResponseErrorCode_name, int32(x))
}

func (RpcShutdownResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 1, 0, 0}
}

type RpcConfigGetResponseErrorCode int32

const (
	RpcConfigGetResponseError_NULL             RpcConfigGetResponseErrorCode = 0
	RpcConfigGetResponseError_UNKNOWN_ERROR    RpcConfigGetResponseErrorCode = 1
	RpcConfigGetResponseError_BAD_INPUT        RpcConfigGetResponseErrorCode = 2
	RpcConfigGetResponseError_NODE_NOT_STARTED RpcConfigGetResponseErrorCode = 101
)

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

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

func (x RpcConfigGetResponseErrorCode) String() string {
	return proto.EnumName(RpcConfigGetResponseErrorCode_name, int32(x))
}

func (RpcConfigGetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 12, 0, 1, 0, 0}
}

type RpcPingResponseErrorCode int32

const (
	RpcPingResponseError_NULL          RpcPingResponseErrorCode = 0
	RpcPingResponseError_UNKNOWN_ERROR RpcPingResponseErrorCode = 1
	RpcPingResponseError_BAD_INPUT     RpcPingResponseErrorCode = 2
)

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

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

func (x RpcPingResponseErrorCode) String() string {
	return proto.EnumName(RpcPingResponseErrorCode_name, int32(x))
}

func (RpcPingResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 13, 1, 0, 0}
}

type RpcProcessCancelResponseErrorCode int32

const (
	RpcProcessCancelResponseError_NULL          RpcProcessCancelResponseErrorCode = 0
	RpcProcessCancelResponseError_UNKNOWN_ERROR RpcProcessCancelResponseErrorCode = 1
	RpcProcessCancelResponseError_BAD_INPUT     RpcProcessCancelResponseErrorCode = 2
)

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

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

func (x RpcProcessCancelResponseErrorCode) String() string {
	return proto.EnumName(RpcProcessCancelResponseErrorCode_name, int32(x))
}

func (RpcProcessCancelResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 0, 1, 0, 0}
}

type RpcLinkPreviewResponseErrorCode int32

const (
	RpcLinkPreviewResponseError_NULL          RpcLinkPreviewResponseErrorCode = 0
	RpcLinkPreviewResponseError_UNKNOWN_ERROR RpcLinkPreviewResponseErrorCode = 1
	RpcLinkPreviewResponseError_BAD_INPUT     RpcLinkPreviewResponseErrorCode = 2
)

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

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

func (x RpcLinkPreviewResponseErrorCode) String() string {
	return proto.EnumName(RpcLinkPreviewResponseErrorCode_name, int32(x))
}

func (RpcLinkPreviewResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 15, 1, 0, 0}
}

type RpcUploadFileResponseErrorCode int32

const (
	RpcUploadFileResponseError_NULL          RpcUploadFileResponseErrorCode = 0
	RpcUploadFileResponseError_UNKNOWN_ERROR RpcUploadFileResponseErrorCode = 1
	RpcUploadFileResponseError_BAD_INPUT     RpcUploadFileResponseErrorCode = 2
)

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

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

func (x RpcUploadFileResponseErrorCode) String() string {
	return proto.EnumName(RpcUploadFileResponseErrorCode_name, int32(x))
}

func (RpcUploadFileResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 1, 0, 0}
}

type RpcDownloadFileResponseErrorCode int32

const (
	RpcDownloadFileResponseError_NULL          RpcDownloadFileResponseErrorCode = 0
	RpcDownloadFileResponseError_UNKNOWN_ERROR RpcDownloadFileResponseErrorCode = 1
	RpcDownloadFileResponseError_BAD_INPUT     RpcDownloadFileResponseErrorCode = 2
	RpcDownloadFileResponseError_NOT_FOUND     RpcDownloadFileResponseErrorCode = 3
)

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

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

func (x RpcDownloadFileResponseErrorCode) String() string {
	return proto.EnumName(RpcDownloadFileResponseErrorCode_name, int32(x))
}

func (RpcDownloadFileResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1, 0, 0}
}

type RpcNavigationContext int32

const (
	RpcNavigation_Navigation RpcNavigationContext = 0
	RpcNavigation_MoveTo     RpcNavigationContext = 1
	RpcNavigation_LinkTo     RpcNavigationContext = 2
)

var RpcNavigationContext_name = map[int32]string{
	0: "Navigation",
	1: "MoveTo",
	2: "LinkTo",
}

var RpcNavigationContext_value = map[string]int32{
	"Navigation": 0,
	"MoveTo":     1,
	"LinkTo":     2,
}

func (x RpcNavigationContext) String() string {
	return proto.EnumName(RpcNavigationContext_name, int32(x))
}

func (RpcNavigationContext) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0}
}

type RpcNavigationListObjectsResponseErrorCode int32

const (
	RpcNavigationListObjectsResponseError_NULL          RpcNavigationListObjectsResponseErrorCode = 0
	RpcNavigationListObjectsResponseError_UNKNOWN_ERROR RpcNavigationListObjectsResponseErrorCode = 1
	RpcNavigationListObjectsResponseError_BAD_INPUT     RpcNavigationListObjectsResponseErrorCode = 2
)

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

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

func (x RpcNavigationListObjectsResponseErrorCode) String() string {
	return proto.EnumName(RpcNavigationListObjectsResponseErrorCode_name, int32(x))
}

func (RpcNavigationListObjectsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 1, 0, 0}
}

type RpcNavigationGetObjectInfoWithLinksResponseErrorCode int32

const (
	RpcNavigationGetObjectInfoWithLinksResponseError_NULL          RpcNavigationGetObjectInfoWithLinksResponseErrorCode = 0
	RpcNavigationGetObjectInfoWithLinksResponseError_UNKNOWN_ERROR RpcNavigationGetObjectInfoWithLinksResponseErrorCode = 1
	RpcNavigationGetObjectInfoWithLinksResponseError_BAD_INPUT     RpcNavigationGetObjectInfoWithLinksResponseErrorCode = 2
)

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

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

func (x RpcNavigationGetObjectInfoWithLinksResponseErrorCode) String() string {
	return proto.EnumName(RpcNavigationGetObjectInfoWithLinksResponseErrorCode_name, int32(x))
}

func (RpcNavigationGetObjectInfoWithLinksResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 1, 1, 0, 0}
}

type RpcHistoryVersionsResponseErrorCode int32

const (
	RpcHistoryVersionsResponseError_NULL          RpcHistoryVersionsResponseErrorCode = 0
	RpcHistoryVersionsResponseError_UNKNOWN_ERROR RpcHistoryVersionsResponseErrorCode = 1
	RpcHistoryVersionsResponseError_BAD_INPUT     RpcHistoryVersionsResponseErrorCode = 2
)

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

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

func (x RpcHistoryVersionsResponseErrorCode) String() string {
	return proto.EnumName(RpcHistoryVersionsResponseErrorCode_name, int32(x))
}

func (RpcHistoryVersionsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 2, 0, 0}
}

type RpcHistoryShowResponseErrorCode int32

const (
	RpcHistoryShowResponseError_NULL          RpcHistoryShowResponseErrorCode = 0
	RpcHistoryShowResponseError_UNKNOWN_ERROR RpcHistoryShowResponseErrorCode = 1
	RpcHistoryShowResponseError_BAD_INPUT     RpcHistoryShowResponseErrorCode = 2
)

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

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

func (x RpcHistoryShowResponseErrorCode) String() string {
	return proto.EnumName(RpcHistoryShowResponseErrorCode_name, int32(x))
}

func (RpcHistoryShowResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 1, 0, 0}
}

type RpcHistorySetVersionResponseErrorCode int32

const (
	RpcHistorySetVersionResponseError_NULL          RpcHistorySetVersionResponseErrorCode = 0
	RpcHistorySetVersionResponseError_UNKNOWN_ERROR RpcHistorySetVersionResponseErrorCode = 1
	RpcHistorySetVersionResponseError_BAD_INPUT     RpcHistorySetVersionResponseErrorCode = 2
)

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

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

func (x RpcHistorySetVersionResponseErrorCode) String() string {
	return proto.EnumName(RpcHistorySetVersionResponseErrorCode_name, int32(x))
}

func (RpcHistorySetVersionResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 2, 1, 0, 0}
}

type RpcPageCreateResponseErrorCode int32

const (
	RpcPageCreateResponseError_NULL          RpcPageCreateResponseErrorCode = 0
	RpcPageCreateResponseError_UNKNOWN_ERROR RpcPageCreateResponseErrorCode = 1
	RpcPageCreateResponseError_BAD_INPUT     RpcPageCreateResponseErrorCode = 2
)

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

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

func (x RpcPageCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcPageCreateResponseErrorCode_name, int32(x))
}

func (RpcPageCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 1, 0, 0}
}

type RpcSetCreateResponseErrorCode int32

const (
	RpcSetCreateResponseError_NULL                    RpcSetCreateResponseErrorCode = 0
	RpcSetCreateResponseError_UNKNOWN_ERROR           RpcSetCreateResponseErrorCode = 1
	RpcSetCreateResponseError_BAD_INPUT               RpcSetCreateResponseErrorCode = 2
	RpcSetCreateResponseError_UNKNOWN_OBJECT_TYPE_URL RpcSetCreateResponseErrorCode = 3
)

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

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

func (x RpcSetCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcSetCreateResponseErrorCode_name, int32(x))
}

func (RpcSetCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 1, 0, 0}
}

type RpcObjectTypeListResponseErrorCode int32

const (
	RpcObjectTypeListResponseError_NULL          RpcObjectTypeListResponseErrorCode = 0
	RpcObjectTypeListResponseError_UNKNOWN_ERROR RpcObjectTypeListResponseErrorCode = 1
	RpcObjectTypeListResponseError_BAD_INPUT     RpcObjectTypeListResponseErrorCode = 2
)

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

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

func (x RpcObjectTypeListResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectTypeListResponseErrorCode_name, int32(x))
}

func (RpcObjectTypeListResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 0, 1, 0, 0}
}

type RpcObjectTypeCreateResponseErrorCode int32

const (
	RpcObjectTypeCreateResponseError_NULL                    RpcObjectTypeCreateResponseErrorCode = 0
	RpcObjectTypeCreateResponseError_UNKNOWN_ERROR           RpcObjectTypeCreateResponseErrorCode = 1
	RpcObjectTypeCreateResponseError_BAD_INPUT               RpcObjectTypeCreateResponseErrorCode = 2
	RpcObjectTypeCreateResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectTypeCreateResponseErrorCode = 3
)

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

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

func (x RpcObjectTypeCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectTypeCreateResponseErrorCode_name, int32(x))
}

func (RpcObjectTypeCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 1, 1, 0, 0}
}

type RpcObjectTypeRelationAddResponseErrorCode int32

const (
	RpcObjectTypeRelationAddResponseError_NULL                    RpcObjectTypeRelationAddResponseErrorCode = 0
	RpcObjectTypeRelationAddResponseError_UNKNOWN_ERROR           RpcObjectTypeRelationAddResponseErrorCode = 1
	RpcObjectTypeRelationAddResponseError_BAD_INPUT               RpcObjectTypeRelationAddResponseErrorCode = 2
	RpcObjectTypeRelationAddResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectTypeRelationAddResponseErrorCode = 3
	RpcObjectTypeRelationAddResponseError_READONLY_OBJECT_TYPE    RpcObjectTypeRelationAddResponseErrorCode = 4
)

var RpcObjectTypeRelationAddResponseErrorCode_name = map[int32]string{
	0: "NULL",
	1: "UNKNOWN_ERROR",
	2: "BAD_INPUT",
	3: "UNKNOWN_OBJECT_TYPE_URL",
	4: "READONLY_OBJECT_TYPE",
}

var RpcObjectTypeRelationAddResponseErrorCode_value = map[string]int32{
	"NULL":                    0,
	"UNKNOWN_ERROR":           1,
	"BAD_INPUT":               2,
	"UNKNOWN_OBJECT_TYPE_URL": 3,
	"READONLY_OBJECT_TYPE":    4,
}

func (x RpcObjectTypeRelationAddResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectTypeRelationAddResponseErrorCode_name, int32(x))
}

func (RpcObjectTypeRelationAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 0, 1, 0, 0}
}

type RpcObjectTypeRelationRemoveResponseErrorCode int32

const (
	RpcObjectTypeRelationRemoveResponseError_NULL                    RpcObjectTypeRelationRemoveResponseErrorCode = 0
	RpcObjectTypeRelationRemoveResponseError_UNKNOWN_ERROR           RpcObjectTypeRelationRemoveResponseErrorCode = 1
	RpcObjectTypeRelationRemoveResponseError_BAD_INPUT               RpcObjectTypeRelationRemoveResponseErrorCode = 2
	RpcObjectTypeRelationRemoveResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectTypeRelationRemoveResponseErrorCode = 3
	RpcObjectTypeRelationRemoveResponseError_READONLY_OBJECT_TYPE    RpcObjectTypeRelationRemoveResponseErrorCode = 4
)

var RpcObjectTypeRelationRemoveResponseErrorCode_name = map[int32]string{
	0: "NULL",
	1: "UNKNOWN_ERROR",
	2: "BAD_INPUT",
	3: "UNKNOWN_OBJECT_TYPE_URL",
	4: "READONLY_OBJECT_TYPE",
}

var RpcObjectTypeRelationRemoveResponseErrorCode_value = map[string]int32{
	"NULL":                    0,
	"UNKNOWN_ERROR":           1,
	"BAD_INPUT":               2,
	"UNKNOWN_OBJECT_TYPE_URL": 3,
	"READONLY_OBJECT_TYPE":    4,
}

func (x RpcObjectTypeRelationRemoveResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectTypeRelationRemoveResponseErrorCode_name, int32(x))
}

func (RpcObjectTypeRelationRemoveResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 1, 1, 0, 0}
}

type RpcObjectTypeRelationUpdateResponseErrorCode int32

const (
	RpcObjectTypeRelationUpdateResponseError_NULL                    RpcObjectTypeRelationUpdateResponseErrorCode = 0
	RpcObjectTypeRelationUpdateResponseError_UNKNOWN_ERROR           RpcObjectTypeRelationUpdateResponseErrorCode = 1
	RpcObjectTypeRelationUpdateResponseError_BAD_INPUT               RpcObjectTypeRelationUpdateResponseErrorCode = 2
	RpcObjectTypeRelationUpdateResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectTypeRelationUpdateResponseErrorCode = 3
	RpcObjectTypeRelationUpdateResponseError_READONLY_OBJECT_TYPE    RpcObjectTypeRelationUpdateResponseErrorCode = 4
)

var RpcObjectTypeRelationUpdateResponseErrorCode_name = map[int32]string{
	0: "NULL",
	1: "UNKNOWN_ERROR",
	2: "BAD_INPUT",
	3: "UNKNOWN_OBJECT_TYPE_URL",
	4: "READONLY_OBJECT_TYPE",
}

var RpcObjectTypeRelationUpdateResponseErrorCode_value = map[string]int32{
	"NULL":                    0,
	"UNKNOWN_ERROR":           1,
	"BAD_INPUT":               2,
	"UNKNOWN_OBJECT_TYPE_URL": 3,
	"READONLY_OBJECT_TYPE":    4,
}

func (x RpcObjectTypeRelationUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectTypeRelationUpdateResponseErrorCode_name, int32(x))
}

func (RpcObjectTypeRelationUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 2, 1, 0, 0}
}

type RpcObjectTypeRelationListResponseErrorCode int32

const (
	RpcObjectTypeRelationListResponseError_NULL                    RpcObjectTypeRelationListResponseErrorCode = 0
	RpcObjectTypeRelationListResponseError_UNKNOWN_ERROR           RpcObjectTypeRelationListResponseErrorCode = 1
	RpcObjectTypeRelationListResponseError_BAD_INPUT               RpcObjectTypeRelationListResponseErrorCode = 2
	RpcObjectTypeRelationListResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectTypeRelationListResponseErrorCode = 3
)

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

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

func (x RpcObjectTypeRelationListResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectTypeRelationListResponseErrorCode_name, int32(x))
}

func (RpcObjectTypeRelationListResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 3, 1, 0, 0}
}

type RpcObjectShareByLinkResponseErrorCode int32

const (
	RpcObjectShareByLinkResponseError_NULL          RpcObjectShareByLinkResponseErrorCode = 0
	RpcObjectShareByLinkResponseError_UNKNOWN_ERROR RpcObjectShareByLinkResponseErrorCode = 1
	RpcObjectShareByLinkResponseError_BAD_INPUT     RpcObjectShareByLinkResponseErrorCode = 2
)

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

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

func (x RpcObjectShareByLinkResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectShareByLinkResponseErrorCode_name, int32(x))
}

func (RpcObjectShareByLinkResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 0, 1, 0, 0}
}

type RpcObjectAddWithObjectIdResponseErrorCode int32

const (
	RpcObjectAddWithObjectIdResponseError_NULL          RpcObjectAddWithObjectIdResponseErrorCode = 0
	RpcObjectAddWithObjectIdResponseError_UNKNOWN_ERROR RpcObjectAddWithObjectIdResponseErrorCode = 1
	RpcObjectAddWithObjectIdResponseError_BAD_INPUT     RpcObjectAddWithObjectIdResponseErrorCode = 2
)

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

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

func (x RpcObjectAddWithObjectIdResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectAddWithObjectIdResponseErrorCode_name, int32(x))
}

func (RpcObjectAddWithObjectIdResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 1, 1, 0, 0}
}

type RpcObjectRelationAddResponseErrorCode int32

const (
	RpcObjectRelationAddResponseError_NULL           RpcObjectRelationAddResponseErrorCode = 0
	RpcObjectRelationAddResponseError_UNKNOWN_ERROR  RpcObjectRelationAddResponseErrorCode = 1
	RpcObjectRelationAddResponseError_BAD_INPUT      RpcObjectRelationAddResponseErrorCode = 2
	RpcObjectRelationAddResponseError_ALREADY_EXISTS RpcObjectRelationAddResponseErrorCode = 10
)

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

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

func (x RpcObjectRelationAddResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationAddResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 2, 1, 0, 0}
}

type RpcObjectRelationUpdateResponseErrorCode int32

const (
	RpcObjectRelationUpdateResponseError_NULL          RpcObjectRelationUpdateResponseErrorCode = 0
	RpcObjectRelationUpdateResponseError_UNKNOWN_ERROR RpcObjectRelationUpdateResponseErrorCode = 1
	RpcObjectRelationUpdateResponseError_BAD_INPUT     RpcObjectRelationUpdateResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationUpdateResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 3, 1, 0, 0}
}

type RpcObjectRelationDeleteResponseErrorCode int32

const (
	RpcObjectRelationDeleteResponseError_NULL          RpcObjectRelationDeleteResponseErrorCode = 0
	RpcObjectRelationDeleteResponseError_UNKNOWN_ERROR RpcObjectRelationDeleteResponseErrorCode = 1
	RpcObjectRelationDeleteResponseError_BAD_INPUT     RpcObjectRelationDeleteResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationDeleteResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 4, 1, 0, 0}
}

type RpcObjectRelationOptionAddResponseErrorCode int32

const (
	RpcObjectRelationOptionAddResponseError_NULL          RpcObjectRelationOptionAddResponseErrorCode = 0
	RpcObjectRelationOptionAddResponseError_UNKNOWN_ERROR RpcObjectRelationOptionAddResponseErrorCode = 1
	RpcObjectRelationOptionAddResponseError_BAD_INPUT     RpcObjectRelationOptionAddResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationOptionAddResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationOptionAddResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationOptionAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 5, 1, 0, 0}
}

type RpcObjectRelationOptionUpdateResponseErrorCode int32

const (
	RpcObjectRelationOptionUpdateResponseError_NULL          RpcObjectRelationOptionUpdateResponseErrorCode = 0
	RpcObjectRelationOptionUpdateResponseError_UNKNOWN_ERROR RpcObjectRelationOptionUpdateResponseErrorCode = 1
	RpcObjectRelationOptionUpdateResponseError_BAD_INPUT     RpcObjectRelationOptionUpdateResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationOptionUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationOptionUpdateResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationOptionUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 6, 1, 0, 0}
}

type RpcObjectRelationOptionDeleteResponseErrorCode int32

const (
	RpcObjectRelationOptionDeleteResponseError_NULL                                             RpcObjectRelationOptionDeleteResponseErrorCode = 0
	RpcObjectRelationOptionDeleteResponseError_UNKNOWN_ERROR                                    RpcObjectRelationOptionDeleteResponseErrorCode = 1
	RpcObjectRelationOptionDeleteResponseError_BAD_INPUT                                        RpcObjectRelationOptionDeleteResponseErrorCode = 2
	RpcObjectRelationOptionDeleteResponseError_SOME_RECORDS_HAS_RELATION_VALUE_WITH_THIS_OPTION RpcObjectRelationOptionDeleteResponseErrorCode = 3
)

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

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

func (x RpcObjectRelationOptionDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationOptionDeleteResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationOptionDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 7, 1, 0, 0}
}

type RpcObjectRelationListAvailableResponseErrorCode int32

const (
	RpcObjectRelationListAvailableResponseError_NULL          RpcObjectRelationListAvailableResponseErrorCode = 0
	RpcObjectRelationListAvailableResponseError_UNKNOWN_ERROR RpcObjectRelationListAvailableResponseErrorCode = 1
	RpcObjectRelationListAvailableResponseError_BAD_INPUT     RpcObjectRelationListAvailableResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationListAvailableResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationListAvailableResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationListAvailableResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 8, 1, 0, 0}
}

type RpcObjectSearchResponseErrorCode int32

const (
	RpcObjectSearchResponseError_NULL          RpcObjectSearchResponseErrorCode = 0
	RpcObjectSearchResponseError_UNKNOWN_ERROR RpcObjectSearchResponseErrorCode = 1
	RpcObjectSearchResponseError_BAD_INPUT     RpcObjectSearchResponseErrorCode = 2
)

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

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

func (x RpcObjectSearchResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSearchResponseErrorCode_name, int32(x))
}

func (RpcObjectSearchResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 9, 1, 0, 0}
}

type RpcObjectGraphEdgeType int32

const (
	RpcObjectGraphEdge_Link     RpcObjectGraphEdgeType = 0
	RpcObjectGraphEdge_Relation RpcObjectGraphEdgeType = 1
)

var RpcObjectGraphEdgeType_name = map[int32]string{
	0: "Link",
	1: "Relation",
}

var RpcObjectGraphEdgeType_value = map[string]int32{
	"Link":     0,
	"Relation": 1,
}

func (x RpcObjectGraphEdgeType) String() string {
	return proto.EnumName(RpcObjectGraphEdgeType_name, int32(x))
}

func (RpcObjectGraphEdgeType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 2, 0}
}

type RpcObjectGraphResponseErrorCode int32

const (
	RpcObjectGraphResponseError_NULL          RpcObjectGraphResponseErrorCode = 0
	RpcObjectGraphResponseError_UNKNOWN_ERROR RpcObjectGraphResponseErrorCode = 1
	RpcObjectGraphResponseError_BAD_INPUT     RpcObjectGraphResponseErrorCode = 2
)

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

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

func (x RpcObjectGraphResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectGraphResponseErrorCode_name, int32(x))
}

func (RpcObjectGraphResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 3, 0, 0}
}

type RpcObjectSearchSubscribeResponseErrorCode int32

const (
	RpcObjectSearchSubscribeResponseError_NULL          RpcObjectSearchSubscribeResponseErrorCode = 0
	RpcObjectSearchSubscribeResponseError_UNKNOWN_ERROR RpcObjectSearchSubscribeResponseErrorCode = 1
	RpcObjectSearchSubscribeResponseError_BAD_INPUT     RpcObjectSearchSubscribeResponseErrorCode = 2
)

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

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

func (x RpcObjectSearchSubscribeResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSearchSubscribeResponseErrorCode_name, int32(x))
}

func (RpcObjectSearchSubscribeResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 11, 1, 0, 0}
}

type RpcObjectIdsSubscribeResponseErrorCode int32

const (
	RpcObjectIdsSubscribeResponseError_NULL          RpcObjectIdsSubscribeResponseErrorCode = 0
	RpcObjectIdsSubscribeResponseError_UNKNOWN_ERROR RpcObjectIdsSubscribeResponseErrorCode = 1
	RpcObjectIdsSubscribeResponseError_BAD_INPUT     RpcObjectIdsSubscribeResponseErrorCode = 2
)

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

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

func (x RpcObjectIdsSubscribeResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectIdsSubscribeResponseErrorCode_name, int32(x))
}

func (RpcObjectIdsSubscribeResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 12, 1, 0, 0}
}

type RpcObjectSearchUnsubscribeResponseErrorCode int32

const (
	RpcObjectSearchUnsubscribeResponseError_NULL          RpcObjectSearchUnsubscribeResponseErrorCode = 0
	RpcObjectSearchUnsubscribeResponseError_UNKNOWN_ERROR RpcObjectSearchUnsubscribeResponseErrorCode = 1
	RpcObjectSearchUnsubscribeResponseError_BAD_INPUT     RpcObjectSearchUnsubscribeResponseErrorCode = 2
)

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

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

func (x RpcObjectSearchUnsubscribeResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSearchUnsubscribeResponseErrorCode_name, int32(x))
}

func (RpcObjectSearchUnsubscribeResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 13, 1, 0, 0}
}

type RpcObjectSetLayoutResponseErrorCode int32

const (
	RpcObjectSetLayoutResponseError_NULL          RpcObjectSetLayoutResponseErrorCode = 0
	RpcObjectSetLayoutResponseError_UNKNOWN_ERROR RpcObjectSetLayoutResponseErrorCode = 1
	RpcObjectSetLayoutResponseError_BAD_INPUT     RpcObjectSetLayoutResponseErrorCode = 2
)

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

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

func (x RpcObjectSetLayoutResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetLayoutResponseErrorCode_name, int32(x))
}

func (RpcObjectSetLayoutResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 14, 1, 0, 0}
}

type RpcObjectSetIsFavoriteResponseErrorCode int32

const (
	RpcObjectSetIsFavoriteResponseError_NULL          RpcObjectSetIsFavoriteResponseErrorCode = 0
	RpcObjectSetIsFavoriteResponseError_UNKNOWN_ERROR RpcObjectSetIsFavoriteResponseErrorCode = 1
	RpcObjectSetIsFavoriteResponseError_BAD_INPUT     RpcObjectSetIsFavoriteResponseErrorCode = 2
)

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

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

func (x RpcObjectSetIsFavoriteResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetIsFavoriteResponseErrorCode_name, int32(x))
}

func (RpcObjectSetIsFavoriteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 15, 1, 0, 0}
}

type RpcObjectSetIsArchivedResponseErrorCode int32

const (
	RpcObjectSetIsArchivedResponseError_NULL          RpcObjectSetIsArchivedResponseErrorCode = 0
	RpcObjectSetIsArchivedResponseError_UNKNOWN_ERROR RpcObjectSetIsArchivedResponseErrorCode = 1
	RpcObjectSetIsArchivedResponseError_BAD_INPUT     RpcObjectSetIsArchivedResponseErrorCode = 2
)

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

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

func (x RpcObjectSetIsArchivedResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetIsArchivedResponseErrorCode_name, int32(x))
}

func (RpcObjectSetIsArchivedResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 16, 1, 0, 0}
}

type RpcObjectFeaturedRelationAddResponseErrorCode int32

const (
	RpcObjectFeaturedRelationAddResponseError_NULL          RpcObjectFeaturedRelationAddResponseErrorCode = 0
	RpcObjectFeaturedRelationAddResponseError_UNKNOWN_ERROR RpcObjectFeaturedRelationAddResponseErrorCode = 1
	RpcObjectFeaturedRelationAddResponseError_BAD_INPUT     RpcObjectFeaturedRelationAddResponseErrorCode = 2
)

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

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

func (x RpcObjectFeaturedRelationAddResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectFeaturedRelationAddResponseErrorCode_name, int32(x))
}

func (RpcObjectFeaturedRelationAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 0, 1, 0, 0}
}

type RpcObjectFeaturedRelationRemoveResponseErrorCode int32

const (
	RpcObjectFeaturedRelationRemoveResponseError_NULL          RpcObjectFeaturedRelationRemoveResponseErrorCode = 0
	RpcObjectFeaturedRelationRemoveResponseError_UNKNOWN_ERROR RpcObjectFeaturedRelationRemoveResponseErrorCode = 1
	RpcObjectFeaturedRelationRemoveResponseError_BAD_INPUT     RpcObjectFeaturedRelationRemoveResponseErrorCode = 2
)

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

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

func (x RpcObjectFeaturedRelationRemoveResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectFeaturedRelationRemoveResponseErrorCode_name, int32(x))
}

func (RpcObjectFeaturedRelationRemoveResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 1, 1, 0, 0}
}

type RpcObjectToSetResponseErrorCode int32

const (
	RpcObjectToSetResponseError_NULL          RpcObjectToSetResponseErrorCode = 0
	RpcObjectToSetResponseError_UNKNOWN_ERROR RpcObjectToSetResponseErrorCode = 1
	RpcObjectToSetResponseError_BAD_INPUT     RpcObjectToSetResponseErrorCode = 2
)

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

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

func (x RpcObjectToSetResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectToSetResponseErrorCode_name, int32(x))
}

func (RpcObjectToSetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 18, 1, 0, 0}
}

type RpcObjectListDeleteResponseErrorCode int32

const (
	RpcObjectListDeleteResponseError_NULL          RpcObjectListDeleteResponseErrorCode = 0
	RpcObjectListDeleteResponseError_UNKNOWN_ERROR RpcObjectListDeleteResponseErrorCode = 1
	RpcObjectListDeleteResponseError_BAD_INPUT     RpcObjectListDeleteResponseErrorCode = 2
)

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

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

func (x RpcObjectListDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectListDeleteResponseErrorCode_name, int32(x))
}

func (RpcObjectListDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 1, 0, 0}
}

type RpcObjectListSetIsArchivedResponseErrorCode int32

const (
	RpcObjectListSetIsArchivedResponseError_NULL          RpcObjectListSetIsArchivedResponseErrorCode = 0
	RpcObjectListSetIsArchivedResponseError_UNKNOWN_ERROR RpcObjectListSetIsArchivedResponseErrorCode = 1
	RpcObjectListSetIsArchivedResponseError_BAD_INPUT     RpcObjectListSetIsArchivedResponseErrorCode = 2
)

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

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

func (x RpcObjectListSetIsArchivedResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectListSetIsArchivedResponseErrorCode_name, int32(x))
}

func (RpcObjectListSetIsArchivedResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 0, 1, 0, 0}
}

type RpcObjectListSetIsFavoriteResponseErrorCode int32

const (
	RpcObjectListSetIsFavoriteResponseError_NULL          RpcObjectListSetIsFavoriteResponseErrorCode = 0
	RpcObjectListSetIsFavoriteResponseError_UNKNOWN_ERROR RpcObjectListSetIsFavoriteResponseErrorCode = 1
	RpcObjectListSetIsFavoriteResponseError_BAD_INPUT     RpcObjectListSetIsFavoriteResponseErrorCode = 2
)

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

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

func (x RpcObjectListSetIsFavoriteResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectListSetIsFavoriteResponseErrorCode_name, int32(x))
}

func (RpcObjectListSetIsFavoriteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 1, 1, 0, 0}
}

type RpcExportFormat int32

const (
	RpcExport_Markdown   RpcExportFormat = 0
	RpcExport_Protobuf   RpcExportFormat = 1
	RpcExport_JSON       RpcExportFormat = 2
	RpcExport_DOT        RpcExportFormat = 3
	RpcExport_SVG        RpcExportFormat = 4
	RpcExport_GRAPH_JSON RpcExportFormat = 5
)

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

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

func (x RpcExportFormat) String() string {
	return proto.EnumName(RpcExportFormat_name, int32(x))
}

func (RpcExportFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 0}
}

type RpcExportResponseErrorCode int32

const (
	RpcExportResponseError_NULL          RpcExportResponseErrorCode = 0
	RpcExportResponseError_UNKNOWN_ERROR RpcExportResponseErrorCode = 1
	RpcExportResponseError_BAD_INPUT     RpcExportResponseErrorCode = 2
)

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

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

func (x RpcExportResponseErrorCode) String() string {
	return proto.EnumName(RpcExportResponseErrorCode_name, int32(x))
}

func (RpcExportResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 1, 0, 0}
}

type RpcExportWorkspaceResponseErrorCode int32

const (
	RpcExportWorkspaceResponseError_NULL          RpcExportWorkspaceResponseErrorCode = 0
	RpcExportWorkspaceResponseError_UNKNOWN_ERROR RpcExportWorkspaceResponseErrorCode = 1
	RpcExportWorkspaceResponseError_BAD_INPUT     RpcExportWorkspaceResponseErrorCode = 2
)

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

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

func (x RpcExportWorkspaceResponseErrorCode) String() string {
	return proto.EnumName(RpcExportWorkspaceResponseErrorCode_name, int32(x))
}

func (RpcExportWorkspaceResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 1, 0, 0}
}

type RpcExportTemplatesResponseErrorCode int32

const (
	RpcExportTemplatesResponseError_NULL          RpcExportTemplatesResponseErrorCode = 0
	RpcExportTemplatesResponseError_UNKNOWN_ERROR RpcExportTemplatesResponseErrorCode = 1
	RpcExportTemplatesResponseError_BAD_INPUT     RpcExportTemplatesResponseErrorCode = 2
)

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

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

func (x RpcExportTemplatesResponseErrorCode) String() string {
	return proto.EnumName(RpcExportTemplatesResponseErrorCode_name, int32(x))
}

func (RpcExportTemplatesResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 27, 1, 0, 0}
}

type RpcExportLocalstoreResponseErrorCode int32

const (
	RpcExportLocalstoreResponseError_NULL          RpcExportLocalstoreResponseErrorCode = 0
	RpcExportLocalstoreResponseError_UNKNOWN_ERROR RpcExportLocalstoreResponseErrorCode = 1
	RpcExportLocalstoreResponseError_BAD_INPUT     RpcExportLocalstoreResponseErrorCode = 2
)

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

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

func (x RpcExportLocalstoreResponseErrorCode) String() string {
	return proto.EnumName(RpcExportLocalstoreResponseErrorCode_name, int32(x))
}

func (RpcExportLocalstoreResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 28, 1, 0, 0}
}

type RpcMakeTemplateResponseErrorCode int32

const (
	RpcMakeTemplateResponseError_NULL          RpcMakeTemplateResponseErrorCode = 0
	RpcMakeTemplateResponseError_UNKNOWN_ERROR RpcMakeTemplateResponseErrorCode = 1
	RpcMakeTemplateResponseError_BAD_INPUT     RpcMakeTemplateResponseErrorCode = 2
)

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

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

func (x RpcMakeTemplateResponseErrorCode) String() string {
	return proto.EnumName(RpcMakeTemplateResponseErrorCode_name, int32(x))
}

func (RpcMakeTemplateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 29, 1, 0, 0}
}

type RpcMakeTemplateByObjectTypeResponseErrorCode int32

const (
	RpcMakeTemplateByObjectTypeResponseError_NULL          RpcMakeTemplateByObjectTypeResponseErrorCode = 0
	RpcMakeTemplateByObjectTypeResponseError_UNKNOWN_ERROR RpcMakeTemplateByObjectTypeResponseErrorCode = 1
	RpcMakeTemplateByObjectTypeResponseError_BAD_INPUT     RpcMakeTemplateByObjectTypeResponseErrorCode = 2
)

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

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

func (x RpcMakeTemplateByObjectTypeResponseErrorCode) String() string {
	return proto.EnumName(RpcMakeTemplateByObjectTypeResponseErrorCode_name, int32(x))
}

func (RpcMakeTemplateByObjectTypeResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 30, 1, 0, 0}
}

type RpcCloneTemplateResponseErrorCode int32

const (
	RpcCloneTemplateResponseError_NULL          RpcCloneTemplateResponseErrorCode = 0
	RpcCloneTemplateResponseError_UNKNOWN_ERROR RpcCloneTemplateResponseErrorCode = 1
	RpcCloneTemplateResponseError_BAD_INPUT     RpcCloneTemplateResponseErrorCode = 2
)

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

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

func (x RpcCloneTemplateResponseErrorCode) String() string {
	return proto.EnumName(RpcCloneTemplateResponseErrorCode_name, int32(x))
}

func (RpcCloneTemplateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 31, 1, 0, 0}
}

type RpcObjectDuplicateResponseErrorCode int32

const (
	RpcObjectDuplicateResponseError_NULL          RpcObjectDuplicateResponseErrorCode = 0
	RpcObjectDuplicateResponseError_UNKNOWN_ERROR RpcObjectDuplicateResponseErrorCode = 1
	RpcObjectDuplicateResponseError_BAD_INPUT     RpcObjectDuplicateResponseErrorCode = 2
)

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

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

func (x RpcObjectDuplicateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectDuplicateResponseErrorCode_name, int32(x))
}

func (RpcObjectDuplicateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 32, 1, 0, 0}
}

type RpcUnsplashSearchResponseErrorCode int32

const (
	RpcUnsplashSearchResponseError_NULL                RpcUnsplashSearchResponseErrorCode = 0
	RpcUnsplashSearchResponseError_UNKNOWN_ERROR       RpcUnsplashSearchResponseErrorCode = 1
	RpcUnsplashSearchResponseError_BAD_INPUT           RpcUnsplashSearchResponseErrorCode = 2
	RpcUnsplashSearchResponseError_RATE_LIMIT_EXCEEDED RpcUnsplashSearchResponseErrorCode = 100
)

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

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

func (x RpcUnsplashSearchResponseErrorCode) String() string {
	return proto.EnumName(RpcUnsplashSearchResponseErrorCode_name, int32(x))
}

func (RpcUnsplashSearchResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 33, 1, 1, 0}
}

type RpcUnsplashDownloadResponseErrorCode int32

const (
	RpcUnsplashDownloadResponseError_NULL                RpcUnsplashDownloadResponseErrorCode = 0
	RpcUnsplashDownloadResponseError_UNKNOWN_ERROR       RpcUnsplashDownloadResponseErrorCode = 1
	RpcUnsplashDownloadResponseError_BAD_INPUT           RpcUnsplashDownloadResponseErrorCode = 2
	RpcUnsplashDownloadResponseError_RATE_LIMIT_EXCEEDED RpcUnsplashDownloadResponseErrorCode = 100
)

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

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

func (x RpcUnsplashDownloadResponseErrorCode) String() string {
	return proto.EnumName(RpcUnsplashDownloadResponseErrorCode_name, int32(x))
}

func (RpcUnsplashDownloadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 34, 1, 0, 0}
}

type RpcApplyTemplateResponseErrorCode int32

const (
	RpcApplyTemplateResponseError_NULL          RpcApplyTemplateResponseErrorCode = 0
	RpcApplyTemplateResponseError_UNKNOWN_ERROR RpcApplyTemplateResponseErrorCode = 1
	RpcApplyTemplateResponseError_BAD_INPUT     RpcApplyTemplateResponseErrorCode = 2
)

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

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

func (x RpcApplyTemplateResponseErrorCode) String() string {
	return proto.EnumName(RpcApplyTemplateResponseErrorCode_name, int32(x))
}

func (RpcApplyTemplateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 35, 1, 0, 0}
}

type RpcDebugSyncResponseErrorCode int32

const (
	RpcDebugSyncResponseError_NULL          RpcDebugSyncResponseErrorCode = 0
	RpcDebugSyncResponseError_UNKNOWN_ERROR RpcDebugSyncResponseErrorCode = 1
	RpcDebugSyncResponseError_BAD_INPUT     RpcDebugSyncResponseErrorCode = 2
)

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

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

func (x RpcDebugSyncResponseErrorCode) String() string {
	return proto.EnumName(RpcDebugSyncResponseErrorCode_name, int32(x))
}

func (RpcDebugSyncResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 2, 1, 0, 0}
}

type RpcDebugThreadResponseErrorCode int32

const (
	RpcDebugThreadResponseError_NULL          RpcDebugThreadResponseErrorCode = 0
	RpcDebugThreadResponseError_UNKNOWN_ERROR RpcDebugThreadResponseErrorCode = 1
	RpcDebugThreadResponseError_BAD_INPUT     RpcDebugThreadResponseErrorCode = 2
)

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

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

func (x RpcDebugThreadResponseErrorCode) String() string {
	return proto.EnumName(RpcDebugThreadResponseErrorCode_name, int32(x))
}

func (RpcDebugThreadResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 3, 1, 0, 0}
}

type RpcDebugTreeResponseErrorCode int32

const (
	RpcDebugTreeResponseError_NULL          RpcDebugTreeResponseErrorCode = 0
	RpcDebugTreeResponseError_UNKNOWN_ERROR RpcDebugTreeResponseErrorCode = 1
	RpcDebugTreeResponseError_BAD_INPUT     RpcDebugTreeResponseErrorCode = 2
)

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

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

func (x RpcDebugTreeResponseErrorCode) String() string {
	return proto.EnumName(RpcDebugTreeResponseErrorCode_name, int32(x))
}

func (RpcDebugTreeResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 4, 1, 0, 0}
}

type RpcGenericErrorResponseErrorCode int32

const (
	RpcGenericErrorResponseError_NULL          RpcGenericErrorResponseErrorCode = 0
	RpcGenericErrorResponseError_UNKNOWN_ERROR RpcGenericErrorResponseErrorCode = 1
	RpcGenericErrorResponseError_BAD_INPUT     RpcGenericErrorResponseErrorCode = 2
)

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

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

func (x RpcGenericErrorResponseErrorCode) String() string {
	return proto.EnumName(RpcGenericErrorResponseErrorCode_name, int32(x))
}

func (RpcGenericErrorResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 37, 0, 0}
}

//
// Rpc is a namespace, that agregates all of the service commands between client and middleware.
// Structure: Topic > Subtopic > Subsub... > Action > (Request, Response).
// Request – message from a client.
// Response – message from a middleware.
type Rpc struct {
}

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

var xxx_messageInfo_Rpc proto.InternalMessageInfo

type RpcMetrics struct {
}

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

var xxx_messageInfo_RpcMetrics proto.InternalMessageInfo

type RpcMetricsSetParameters struct {
}

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

var xxx_messageInfo_RpcMetricsSetParameters proto.InternalMessageInfo

type RpcMetricsSetParametersRequest struct {
	Platform string `protobuf:"bytes,1,opt,name=platform,proto3" json:"platform,omitempty"`
}

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

var xxx_messageInfo_RpcMetricsSetParametersRequest proto.InternalMessageInfo

func (m *RpcMetricsSetParametersRequest) GetPlatform() string {
	if m != nil {
		return m.Platform
	}
	return ""
}

type RpcMetricsSetParametersResponse struct {
	Error *RpcMetricsSetParametersResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcMetricsSetParametersResponse proto.InternalMessageInfo

func (m *RpcMetricsSetParametersResponse) GetError() *RpcMetricsSetParametersResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcMetricsSetParametersResponseError struct {
	Code        RpcMetricsSetParametersResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcMetricsSetParametersResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcMetricsSetParametersResponseError proto.InternalMessageInfo

func (m *RpcMetricsSetParametersResponseError) GetCode() RpcMetricsSetParametersResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcMetricsSetParametersResponseError_NULL
}

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

type RpcExternalDrop struct {
}

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

var xxx_messageInfo_RpcExternalDrop proto.InternalMessageInfo

type RpcExternalDropFiles struct {
}

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

var xxx_messageInfo_RpcExternalDropFiles proto.InternalMessageInfo

type RpcExternalDropFilesRequest struct {
	ContextId      string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	DropTargetId   string              `protobuf:"bytes,2,opt,name=dropTargetId,proto3" json:"dropTargetId,omitempty"`
	Position       model.BlockPosition `protobuf:"varint,3,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	LocalFilePaths []string            `protobuf:"bytes,4,rep,name=localFilePaths,proto3" json:"localFilePaths,omitempty"`
}

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

var xxx_messageInfo_RpcExternalDropFilesRequest proto.InternalMessageInfo

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

func (m *RpcExternalDropFilesRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcExternalDropFilesRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *RpcExternalDropFilesRequest) GetLocalFilePaths() []string {
	if m != nil {
		return m.LocalFilePaths
	}
	return nil
}

type RpcExternalDropFilesResponse struct {
	Error *RpcExternalDropFilesResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcExternalDropFilesResponse proto.InternalMessageInfo

func (m *RpcExternalDropFilesResponse) GetError() *RpcExternalDropFilesResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcExternalDropFilesResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcExternalDropFilesResponseError struct {
	Code        RpcExternalDropFilesResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcExternalDropFilesResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcExternalDropFilesResponseError proto.InternalMessageInfo

func (m *RpcExternalDropFilesResponseError) GetCode() RpcExternalDropFilesResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcExternalDropFilesResponseError_NULL
}

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

type RpcExternalDropContent struct {
}

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

var xxx_messageInfo_RpcExternalDropContent proto.InternalMessageInfo

type RpcExternalDropContentRequest struct {
	ContextId      string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	FocusedBlockId string `protobuf:"bytes,2,opt,name=focusedBlockId,proto3" json:"focusedBlockId,omitempty"`
	Content        []byte `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
}

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

var xxx_messageInfo_RpcExternalDropContentRequest proto.InternalMessageInfo

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

func (m *RpcExternalDropContentRequest) GetFocusedBlockId() string {
	if m != nil {
		return m.FocusedBlockId
	}
	return ""
}

func (m *RpcExternalDropContentRequest) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

type RpcExternalDropContentResponse struct {
	Error *RpcExternalDropContentResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcExternalDropContentResponse proto.InternalMessageInfo

func (m *RpcExternalDropContentResponse) GetError() *RpcExternalDropContentResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcExternalDropContentResponseError struct {
	Code        RpcExternalDropContentResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcExternalDropContentResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcExternalDropContentResponseError proto.InternalMessageInfo

func (m *RpcExternalDropContentResponseError) GetCode() RpcExternalDropContentResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcExternalDropContentResponseError_NULL
}

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

type RpcBlockList struct {
}

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

var xxx_messageInfo_RpcBlockList proto.InternalMessageInfo

type RpcBlockListConvertChildrenToPages struct {
}

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

var xxx_messageInfo_RpcBlockListConvertChildrenToPages proto.InternalMessageInfo

type RpcBlockListConvertChildrenToPagesRequest struct {
	ContextId  string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds   []string `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	ObjectType string   `protobuf:"bytes,3,opt,name=objectType,proto3" json:"objectType,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListConvertChildrenToPagesRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListConvertChildrenToPagesResponse struct {
	Error   *RpcBlockListConvertChildrenToPagesResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LinkIds []string                                         `protobuf:"bytes,2,rep,name=linkIds,proto3" json:"linkIds,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListConvertChildrenToPagesResponse proto.InternalMessageInfo

func (m *RpcBlockListConvertChildrenToPagesResponse) GetError() *RpcBlockListConvertChildrenToPagesResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListConvertChildrenToPagesResponse) GetLinkIds() []string {
	if m != nil {
		return m.LinkIds
	}
	return nil
}

type RpcBlockListConvertChildrenToPagesResponseError struct {
	Code        RpcBlockListConvertChildrenToPagesResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListConvertChildrenToPagesResponseErrorCode" json:"code,omitempty"`
	Description string                                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListConvertChildrenToPagesResponseError proto.InternalMessageInfo

func (m *RpcBlockListConvertChildrenToPagesResponseError) GetCode() RpcBlockListConvertChildrenToPagesResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListConvertChildrenToPagesResponseError_NULL
}

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

type RpcBlockListMove struct {
}

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

var xxx_messageInfo_RpcBlockListMove proto.InternalMessageInfo

type RpcBlockListMoveRequest struct {
	ContextId       string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds        []string            `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	TargetContextId string              `protobuf:"bytes,3,opt,name=targetContextId,proto3" json:"targetContextId,omitempty"`
	DropTargetId    string              `protobuf:"bytes,4,opt,name=dropTargetId,proto3" json:"dropTargetId,omitempty"`
	Position        model.BlockPosition `protobuf:"varint,5,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockListMoveRequest) GetTargetContextId() string {
	if m != nil {
		return m.TargetContextId
	}
	return ""
}

func (m *RpcBlockListMoveRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcBlockListMoveRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockListMoveResponse struct {
	Error *RpcBlockListMoveResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                 `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveResponse proto.InternalMessageInfo

func (m *RpcBlockListMoveResponse) GetError() *RpcBlockListMoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListMoveResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListMoveResponseError struct {
	Code        RpcBlockListMoveResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListMoveResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveResponseError proto.InternalMessageInfo

func (m *RpcBlockListMoveResponseError) GetCode() RpcBlockListMoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListMoveResponseError_NULL
}

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

type RpcBlockListMoveToNewPage struct {
}

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

var xxx_messageInfo_RpcBlockListMoveToNewPage proto.InternalMessageInfo

type RpcBlockListMoveToNewPageRequest struct {
	ContextId    string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds     []string            `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Details      *types.Struct       `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
	DropTargetId string              `protobuf:"bytes,4,opt,name=dropTargetId,proto3" json:"dropTargetId,omitempty"`
	Position     model.BlockPosition `protobuf:"varint,5,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveToNewPageRequest proto.InternalMessageInfo

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

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

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

func (m *RpcBlockListMoveToNewPageRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcBlockListMoveToNewPageRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockListMoveToNewPageResponse struct {
	Error  *RpcBlockListMoveToNewPageResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LinkId string                                  `protobuf:"bytes,2,opt,name=linkId,proto3" json:"linkId,omitempty"`
	Event  *ResponseEvent                          `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveToNewPageResponse proto.InternalMessageInfo

func (m *RpcBlockListMoveToNewPageResponse) GetError() *RpcBlockListMoveToNewPageResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListMoveToNewPageResponse) GetLinkId() string {
	if m != nil {
		return m.LinkId
	}
	return ""
}

func (m *RpcBlockListMoveToNewPageResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListMoveToNewPageResponseError struct {
	Code        RpcBlockListMoveToNewPageResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListMoveToNewPageResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveToNewPageResponseError proto.InternalMessageInfo

func (m *RpcBlockListMoveToNewPageResponseError) GetCode() RpcBlockListMoveToNewPageResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListMoveToNewPageResponseError_NULL
}

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

//
// Makes blocks copy by given ids and paste it to shown place
type RpcBlockListDuplicate struct {
}

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

var xxx_messageInfo_RpcBlockListDuplicate proto.InternalMessageInfo

type RpcBlockListDuplicateRequest struct {
	ContextId string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TargetId  string              `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	BlockIds  []string            `protobuf:"bytes,3,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Position  model.BlockPosition `protobuf:"varint,4,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListDuplicateRequest proto.InternalMessageInfo

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

func (m *RpcBlockListDuplicateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

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

func (m *RpcBlockListDuplicateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockListDuplicateResponse struct {
	Error    *RpcBlockListDuplicateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockIds []string                            `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Event    *ResponseEvent                      `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListDuplicateResponse proto.InternalMessageInfo

func (m *RpcBlockListDuplicateResponse) GetError() *RpcBlockListDuplicateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockListDuplicateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListDuplicateResponseError struct {
	Code        RpcBlockListDuplicateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListDuplicateResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListDuplicateResponseError proto.InternalMessageInfo

func (m *RpcBlockListDuplicateResponseError) GetCode() RpcBlockListDuplicateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListDuplicateResponseError_NULL
}

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

type RpcBlockListSet struct {
}

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

var xxx_messageInfo_RpcBlockListSet proto.InternalMessageInfo

// commands acceptable only for text blocks, others will be ignored
type RpcBlockListSetText struct {
}

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

var xxx_messageInfo_RpcBlockListSetText proto.InternalMessageInfo

type RpcBlockListSetTextStyle struct {
}

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

var xxx_messageInfo_RpcBlockListSetTextStyle proto.InternalMessageInfo

type RpcBlockListSetTextStyleRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string                    `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Style     model.BlockContentTextStyle `protobuf:"varint,3,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextStyleRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetTextStyleResponse struct {
	Error *RpcBlockListSetTextStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextStyleResponse proto.InternalMessageInfo

func (m *RpcBlockListSetTextStyleResponse) GetError() *RpcBlockListSetTextStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetTextStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetTextStyleResponseError struct {
	Code        RpcBlockListSetTextStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetTextStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetTextStyleResponseError) GetCode() RpcBlockListSetTextStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetTextStyleResponseError_NULL
}

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

type RpcBlockListSetTextColor struct {
}

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

var xxx_messageInfo_RpcBlockListSetTextColor proto.InternalMessageInfo

type RpcBlockListSetTextColorRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Color     string   `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextColorRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetTextColorResponse struct {
	Error *RpcBlockListSetTextColorResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextColorResponse proto.InternalMessageInfo

func (m *RpcBlockListSetTextColorResponse) GetError() *RpcBlockListSetTextColorResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetTextColorResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetTextColorResponseError struct {
	Code        RpcBlockListSetTextColorResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetTextColorResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextColorResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetTextColorResponseError) GetCode() RpcBlockListSetTextColorResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetTextColorResponseError_NULL
}

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

type RpcBlockListSetTextMark struct {
}

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

var xxx_messageInfo_RpcBlockListSetTextMark proto.InternalMessageInfo

type RpcBlockListSetTextMarkRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string                    `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Mark      *model.BlockContentTextMark `protobuf:"bytes,3,opt,name=mark,proto3" json:"mark,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextMarkRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockListSetTextMarkRequest) GetMark() *model.BlockContentTextMark {
	if m != nil {
		return m.Mark
	}
	return nil
}

type RpcBlockListSetTextMarkResponse struct {
	Error *RpcBlockListSetTextMarkResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextMarkResponse proto.InternalMessageInfo

func (m *RpcBlockListSetTextMarkResponse) GetError() *RpcBlockListSetTextMarkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetTextMarkResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetTextMarkResponseError struct {
	Code        RpcBlockListSetTextMarkResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetTextMarkResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetTextMarkResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetTextMarkResponseError) GetCode() RpcBlockListSetTextMarkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetTextMarkResponseError_NULL
}

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

type RpcBlockListSetBackgroundColor struct {
}

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

var xxx_messageInfo_RpcBlockListSetBackgroundColor proto.InternalMessageInfo

type RpcBlockListSetBackgroundColorRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Color     string   `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetBackgroundColorRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetBackgroundColorResponse struct {
	Error *RpcBlockListSetBackgroundColorResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                               `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetBackgroundColorResponse proto.InternalMessageInfo

func (m *RpcBlockListSetBackgroundColorResponse) GetError() *RpcBlockListSetBackgroundColorResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetBackgroundColorResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetBackgroundColorResponseError struct {
	Code        RpcBlockListSetBackgroundColorResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetBackgroundColorResponseErrorCode" json:"code,omitempty"`
	Description string                                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetBackgroundColorResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetBackgroundColorResponseError) GetCode() RpcBlockListSetBackgroundColorResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetBackgroundColorResponseError_NULL
}

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

type RpcBlockListSetAlign struct {
}

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

var xxx_messageInfo_RpcBlockListSetAlign proto.InternalMessageInfo

type RpcBlockListSetAlignRequest struct {
	ContextId string           `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string         `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Align     model.BlockAlign `protobuf:"varint,3,opt,name=align,proto3,enum=anytype.model.BlockAlign" json:"align,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetAlignRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetAlignResponse struct {
	Error *RpcBlockListSetAlignResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetAlignResponse proto.InternalMessageInfo

func (m *RpcBlockListSetAlignResponse) GetError() *RpcBlockListSetAlignResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetAlignResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetAlignResponseError struct {
	Code        RpcBlockListSetAlignResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetAlignResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetAlignResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetAlignResponseError) GetCode() RpcBlockListSetAlignResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetAlignResponseError_NULL
}

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

type RpcBlockListSetFields struct {
}

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

var xxx_messageInfo_RpcBlockListSetFields proto.InternalMessageInfo

type RpcBlockListSetFieldsRequest struct {
	ContextId   string                                    `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockFields []*RpcBlockListSetFieldsRequestBlockField `protobuf:"bytes,2,rep,name=blockFields,proto3" json:"blockFields,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetFieldsRequest proto.InternalMessageInfo

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

func (m *RpcBlockListSetFieldsRequest) GetBlockFields() []*RpcBlockListSetFieldsRequestBlockField {
	if m != nil {
		return m.BlockFields
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockListSetFieldsRequestBlockField proto.InternalMessageInfo

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

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

type RpcBlockListSetFieldsResponse struct {
	Error *RpcBlockListSetFieldsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                      `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetFieldsResponse proto.InternalMessageInfo

func (m *RpcBlockListSetFieldsResponse) GetError() *RpcBlockListSetFieldsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetFieldsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetFieldsResponseError struct {
	Code        RpcBlockListSetFieldsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetFieldsResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetFieldsResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetFieldsResponseError) GetCode() RpcBlockListSetFieldsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetFieldsResponseError_NULL
}

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

type RpcBlockListSetDiv struct {
}

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

var xxx_messageInfo_RpcBlockListSetDiv proto.InternalMessageInfo

type RpcBlockListSetDivStyle struct {
}

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

var xxx_messageInfo_RpcBlockListSetDivStyle proto.InternalMessageInfo

type RpcBlockListSetDivStyleRequest struct {
	ContextId string                     `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string                   `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Style     model.BlockContentDivStyle `protobuf:"varint,3,opt,name=style,proto3,enum=anytype.model.BlockContentDivStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetDivStyleRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetDivStyleResponse struct {
	Error *RpcBlockListSetDivStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetDivStyleResponse proto.InternalMessageInfo

func (m *RpcBlockListSetDivStyleResponse) GetError() *RpcBlockListSetDivStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetDivStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetDivStyleResponseError struct {
	Code        RpcBlockListSetDivStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetDivStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetDivStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetDivStyleResponseError) GetCode() RpcBlockListSetDivStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetDivStyleResponseError_NULL
}

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

type RpcBlockListSetFile struct {
}

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

var xxx_messageInfo_RpcBlockListSetFile proto.InternalMessageInfo

type RpcBlockListSetFileStyle struct {
}

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

var xxx_messageInfo_RpcBlockListSetFileStyle proto.InternalMessageInfo

type RpcBlockListSetFileStyleRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string                    `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Style     model.BlockContentFileStyle `protobuf:"varint,3,opt,name=style,proto3,enum=anytype.model.BlockContentFileStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetFileStyleRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetFileStyleResponse struct {
	Error *RpcBlockListSetFileStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetFileStyleResponse proto.InternalMessageInfo

func (m *RpcBlockListSetFileStyleResponse) GetError() *RpcBlockListSetFileStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetFileStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListSetFileStyleResponseError struct {
	Code        RpcBlockListSetFileStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListSetFileStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetFileStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetFileStyleResponseError) GetCode() RpcBlockListSetFileStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetFileStyleResponseError_NULL
}

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

type RpcBlockListTurnInto struct {
}

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

var xxx_messageInfo_RpcBlockListTurnInto proto.InternalMessageInfo

type RpcBlockListTurnIntoRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string                    `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	Style     model.BlockContentTextStyle `protobuf:"varint,3,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListTurnIntoRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListTurnIntoResponse struct {
	Error *RpcBlockListTurnIntoResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListTurnIntoResponse proto.InternalMessageInfo

func (m *RpcBlockListTurnIntoResponse) GetError() *RpcBlockListTurnIntoResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListTurnIntoResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockListTurnIntoResponseError struct {
	Code        RpcBlockListTurnIntoResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockListTurnIntoResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListTurnIntoResponseError proto.InternalMessageInfo

func (m *RpcBlockListTurnIntoResponseError) GetCode() RpcBlockListTurnIntoResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListTurnIntoResponseError_NULL
}

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

//
// Namespace, that agregates subtopics and actions, that relates to blocks.
type RpcBlock struct {
}

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

var xxx_messageInfo_RpcBlock proto.InternalMessageInfo

type RpcBlockReplace struct {
}

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

var xxx_messageInfo_RpcBlockReplace proto.InternalMessageInfo

type RpcBlockReplaceRequest struct {
	ContextId string       `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string       `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Block     *model.Block `protobuf:"bytes,3,opt,name=block,proto3" json:"block,omitempty"`
}

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

var xxx_messageInfo_RpcBlockReplaceRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockReplaceRequest) GetBlock() *model.Block {
	if m != nil {
		return m.Block
	}
	return nil
}

type RpcBlockReplaceResponse struct {
	Error   *RpcBlockReplaceResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId string                        `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Event   *ResponseEvent                `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockReplaceResponse proto.InternalMessageInfo

func (m *RpcBlockReplaceResponse) GetError() *RpcBlockReplaceResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockReplaceResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockReplaceResponseError struct {
	Code        RpcBlockReplaceResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockReplaceResponseErrorCode" json:"code,omitempty"`
	Description string                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockReplaceResponseError proto.InternalMessageInfo

func (m *RpcBlockReplaceResponseError) GetCode() RpcBlockReplaceResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockReplaceResponseError_NULL
}

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

type RpcBlockUpdateContent struct {
}

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

var xxx_messageInfo_RpcBlockUpdateContent proto.InternalMessageInfo

type RpcBlockUpdateContentRequest struct {
	ContextId string       `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string       `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Block     *model.Block `protobuf:"bytes,3,opt,name=block,proto3" json:"block,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUpdateContentRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockUpdateContentRequest) GetBlock() *model.Block {
	if m != nil {
		return m.Block
	}
	return nil
}

type RpcBlockUpdateContentResponse struct {
	Error *RpcBlockUpdateContentResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                      `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUpdateContentResponse proto.InternalMessageInfo

func (m *RpcBlockUpdateContentResponse) GetError() *RpcBlockUpdateContentResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockUpdateContentResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockUpdateContentResponseError struct {
	Code        RpcBlockUpdateContentResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockUpdateContentResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUpdateContentResponseError proto.InternalMessageInfo

func (m *RpcBlockUpdateContentResponseError) GetCode() RpcBlockUpdateContentResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockUpdateContentResponseError_NULL
}

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

type RpcBlockSplit struct {
}

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

var xxx_messageInfo_RpcBlockSplit proto.InternalMessageInfo

type RpcBlockSplitRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string                      `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Range     *model.Range                `protobuf:"bytes,3,opt,name=range,proto3" json:"range,omitempty"`
	Style     model.BlockContentTextStyle `protobuf:"varint,4,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle" json:"style,omitempty"`
	Mode      RpcBlockSplitRequestMode    `protobuf:"varint,5,opt,name=mode,proto3,enum=anytype.RpcBlockSplitRequestMode" json:"mode,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSplitRequest proto.InternalMessageInfo

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

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

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

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

func (m *RpcBlockSplitRequest) GetMode() RpcBlockSplitRequestMode {
	if m != nil {
		return m.Mode
	}
	return RpcBlockSplitRequest_BOTTOM
}

type RpcBlockSplitResponse struct {
	Error   *RpcBlockSplitResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId string                      `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Event   *ResponseEvent              `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSplitResponse proto.InternalMessageInfo

func (m *RpcBlockSplitResponse) GetError() *RpcBlockSplitResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockSplitResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSplitResponseError struct {
	Code        RpcBlockSplitResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSplitResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSplitResponseError proto.InternalMessageInfo

func (m *RpcBlockSplitResponseError) GetCode() RpcBlockSplitResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSplitResponseError_NULL
}

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

type RpcBlockMerge struct {
}

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

var xxx_messageInfo_RpcBlockMerge proto.InternalMessageInfo

type RpcBlockMergeRequest struct {
	ContextId     string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	FirstBlockId  string `protobuf:"bytes,2,opt,name=firstBlockId,proto3" json:"firstBlockId,omitempty"`
	SecondBlockId string `protobuf:"bytes,3,opt,name=secondBlockId,proto3" json:"secondBlockId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockMergeRequest proto.InternalMessageInfo

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

func (m *RpcBlockMergeRequest) GetFirstBlockId() string {
	if m != nil {
		return m.FirstBlockId
	}
	return ""
}

func (m *RpcBlockMergeRequest) GetSecondBlockId() string {
	if m != nil {
		return m.SecondBlockId
	}
	return ""
}

type RpcBlockMergeResponse struct {
	Error *RpcBlockMergeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockMergeResponse proto.InternalMessageInfo

func (m *RpcBlockMergeResponse) GetError() *RpcBlockMergeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockMergeResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockMergeResponseError struct {
	Code        RpcBlockMergeResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockMergeResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockMergeResponseError proto.InternalMessageInfo

func (m *RpcBlockMergeResponseError) GetCode() RpcBlockMergeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockMergeResponseError_NULL
}

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

type RpcBlockCopy struct {
}

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

var xxx_messageInfo_RpcBlockCopy proto.InternalMessageInfo

type RpcBlockCopyRequest struct {
	ContextId         string         `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Blocks            []*model.Block `protobuf:"bytes,2,rep,name=blocks,proto3" json:"blocks,omitempty"`
	SelectedTextRange *model.Range   `protobuf:"bytes,3,opt,name=selectedTextRange,proto3" json:"selectedTextRange,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCopyRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockCopyRequest) GetSelectedTextRange() *model.Range {
	if m != nil {
		return m.SelectedTextRange
	}
	return nil
}

type RpcBlockCopyResponse struct {
	Error    *RpcBlockCopyResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	TextSlot string                     `protobuf:"bytes,2,opt,name=textSlot,proto3" json:"textSlot,omitempty"`
	HtmlSlot string                     `protobuf:"bytes,3,opt,name=htmlSlot,proto3" json:"htmlSlot,omitempty"`
	AnySlot  []*model.Block             `protobuf:"bytes,4,rep,name=anySlot,proto3" json:"anySlot,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCopyResponse proto.InternalMessageInfo

func (m *RpcBlockCopyResponse) GetError() *RpcBlockCopyResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockCopyResponse) GetTextSlot() string {
	if m != nil {
		return m.TextSlot
	}
	return ""
}

func (m *RpcBlockCopyResponse) GetHtmlSlot() string {
	if m != nil {
		return m.HtmlSlot
	}
	return ""
}

func (m *RpcBlockCopyResponse) GetAnySlot() []*model.Block {
	if m != nil {
		return m.AnySlot
	}
	return nil
}

type RpcBlockCopyResponseError struct {
	Code        RpcBlockCopyResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockCopyResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCopyResponseError proto.InternalMessageInfo

func (m *RpcBlockCopyResponseError) GetCode() RpcBlockCopyResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCopyResponseError_NULL
}

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

type RpcBlockPaste struct {
}

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

var xxx_messageInfo_RpcBlockPaste proto.InternalMessageInfo

type RpcBlockPasteRequest struct {
	ContextId         string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	FocusedBlockId    string                      `protobuf:"bytes,2,opt,name=focusedBlockId,proto3" json:"focusedBlockId,omitempty"`
	SelectedTextRange *model.Range                `protobuf:"bytes,3,opt,name=selectedTextRange,proto3" json:"selectedTextRange,omitempty"`
	SelectedBlockIds  []string                    `protobuf:"bytes,4,rep,name=selectedBlockIds,proto3" json:"selectedBlockIds,omitempty"`
	IsPartOfBlock     bool                        `protobuf:"varint,5,opt,name=isPartOfBlock,proto3" json:"isPartOfBlock,omitempty"`
	TextSlot          string                      `protobuf:"bytes,6,opt,name=textSlot,proto3" json:"textSlot,omitempty"`
	HtmlSlot          string                      `protobuf:"bytes,7,opt,name=htmlSlot,proto3" json:"htmlSlot,omitempty"`
	AnySlot           []*model.Block              `protobuf:"bytes,8,rep,name=anySlot,proto3" json:"anySlot,omitempty"`
	FileSlot          []*RpcBlockPasteRequestFile `protobuf:"bytes,9,rep,name=fileSlot,proto3" json:"fileSlot,omitempty"`
}

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

var xxx_messageInfo_RpcBlockPasteRequest proto.InternalMessageInfo

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

func (m *RpcBlockPasteRequest) GetFocusedBlockId() string {
	if m != nil {
		return m.FocusedBlockId
	}
	return ""
}

func (m *RpcBlockPasteRequest) GetSelectedTextRange() *model.Range {
	if m != nil {
		return m.SelectedTextRange
	}
	return nil
}

func (m *RpcBlockPasteRequest) GetSelectedBlockIds() []string {
	if m != nil {
		return m.SelectedBlockIds
	}
	return nil
}

func (m *RpcBlockPasteRequest) GetIsPartOfBlock() bool {
	if m != nil {
		return m.IsPartOfBlock
	}
	return false
}

func (m *RpcBlockPasteRequest) GetTextSlot() string {
	if m != nil {
		return m.TextSlot
	}
	return ""
}

func (m *RpcBlockPasteRequest) GetHtmlSlot() string {
	if m != nil {
		return m.HtmlSlot
	}
	return ""
}

func (m *RpcBlockPasteRequest) GetAnySlot() []*model.Block {
	if m != nil {
		return m.AnySlot
	}
	return nil
}

func (m *RpcBlockPasteRequest) GetFileSlot() []*RpcBlockPasteRequestFile {
	if m != nil {
		return m.FileSlot
	}
	return nil
}

type RpcBlockPasteRequestFile struct {
	Name      string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Data      []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	LocalPath string `protobuf:"bytes,3,opt,name=localPath,proto3" json:"localPath,omitempty"`
}

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

var xxx_messageInfo_RpcBlockPasteRequestFile proto.InternalMessageInfo

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

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

func (m *RpcBlockPasteRequestFile) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

type RpcBlockPasteResponse struct {
	Error            *RpcBlockPasteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockIds         []string                    `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
	CaretPosition    int32                       `protobuf:"varint,3,opt,name=caretPosition,proto3" json:"caretPosition,omitempty"`
	IsSameBlockCaret bool                        `protobuf:"varint,4,opt,name=isSameBlockCaret,proto3" json:"isSameBlockCaret,omitempty"`
	Event            *ResponseEvent              `protobuf:"bytes,5,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockPasteResponse proto.InternalMessageInfo

func (m *RpcBlockPasteResponse) GetError() *RpcBlockPasteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockPasteResponse) GetCaretPosition() int32 {
	if m != nil {
		return m.CaretPosition
	}
	return 0
}

func (m *RpcBlockPasteResponse) GetIsSameBlockCaret() bool {
	if m != nil {
		return m.IsSameBlockCaret
	}
	return false
}

func (m *RpcBlockPasteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockPasteResponseError struct {
	Code        RpcBlockPasteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockPasteResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockPasteResponseError proto.InternalMessageInfo

func (m *RpcBlockPasteResponseError) GetCode() RpcBlockPasteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockPasteResponseError_NULL
}

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

type RpcBlockCut struct {
}

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

var xxx_messageInfo_RpcBlockCut proto.InternalMessageInfo

type RpcBlockCutRequest struct {
	ContextId         string         `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Blocks            []*model.Block `protobuf:"bytes,2,rep,name=blocks,proto3" json:"blocks,omitempty"`
	SelectedTextRange *model.Range   `protobuf:"bytes,3,opt,name=selectedTextRange,proto3" json:"selectedTextRange,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCutRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockCutRequest) GetSelectedTextRange() *model.Range {
	if m != nil {
		return m.SelectedTextRange
	}
	return nil
}

type RpcBlockCutResponse struct {
	Error    *RpcBlockCutResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	TextSlot string                    `protobuf:"bytes,2,opt,name=textSlot,proto3" json:"textSlot,omitempty"`
	HtmlSlot string                    `protobuf:"bytes,3,opt,name=htmlSlot,proto3" json:"htmlSlot,omitempty"`
	AnySlot  []*model.Block            `protobuf:"bytes,4,rep,name=anySlot,proto3" json:"anySlot,omitempty"`
	Event    *ResponseEvent            `protobuf:"bytes,5,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCutResponse proto.InternalMessageInfo

func (m *RpcBlockCutResponse) GetError() *RpcBlockCutResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockCutResponse) GetTextSlot() string {
	if m != nil {
		return m.TextSlot
	}
	return ""
}

func (m *RpcBlockCutResponse) GetHtmlSlot() string {
	if m != nil {
		return m.HtmlSlot
	}
	return ""
}

func (m *RpcBlockCutResponse) GetAnySlot() []*model.Block {
	if m != nil {
		return m.AnySlot
	}
	return nil
}

func (m *RpcBlockCutResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockCutResponseError struct {
	Code        RpcBlockCutResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockCutResponseErrorCode" json:"code,omitempty"`
	Description string                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCutResponseError proto.InternalMessageInfo

func (m *RpcBlockCutResponseError) GetCode() RpcBlockCutResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCutResponseError_NULL
}

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

type RpcBlockImportMarkdown struct {
}

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

var xxx_messageInfo_RpcBlockImportMarkdown proto.InternalMessageInfo

type RpcBlockImportMarkdownRequest struct {
	ContextId  string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	ImportPath string `protobuf:"bytes,2,opt,name=importPath,proto3" json:"importPath,omitempty"`
}

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

var xxx_messageInfo_RpcBlockImportMarkdownRequest proto.InternalMessageInfo

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

func (m *RpcBlockImportMarkdownRequest) GetImportPath() string {
	if m != nil {
		return m.ImportPath
	}
	return ""
}

type RpcBlockImportMarkdownResponse struct {
	Error       *RpcBlockImportMarkdownResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	RootLinkIds []string                             `protobuf:"bytes,2,rep,name=rootLinkIds,proto3" json:"rootLinkIds,omitempty"`
	Event       *ResponseEvent                       `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockImportMarkdownResponse proto.InternalMessageInfo

func (m *RpcBlockImportMarkdownResponse) GetError() *RpcBlockImportMarkdownResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockImportMarkdownResponse) GetRootLinkIds() []string {
	if m != nil {
		return m.RootLinkIds
	}
	return nil
}

func (m *RpcBlockImportMarkdownResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockImportMarkdownResponseError struct {
	Code        RpcBlockImportMarkdownResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockImportMarkdownResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockImportMarkdownResponseError proto.InternalMessageInfo

func (m *RpcBlockImportMarkdownResponseError) GetCode() RpcBlockImportMarkdownResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockImportMarkdownResponseError_NULL
}

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

type RpcBlockExport struct {
}

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

var xxx_messageInfo_RpcBlockExport proto.InternalMessageInfo

type RpcBlockExportRequest struct {
	ContextId string         `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Blocks    []*model.Block `protobuf:"bytes,2,rep,name=blocks,proto3" json:"blocks,omitempty"`
}

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

var xxx_messageInfo_RpcBlockExportRequest proto.InternalMessageInfo

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

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

type RpcBlockExportResponse struct {
	Error *RpcBlockExportResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Path  string                       `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Event *ResponseEvent               `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockExportResponse proto.InternalMessageInfo

func (m *RpcBlockExportResponse) GetError() *RpcBlockExportResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockExportResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcBlockExportResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockExportResponseError struct {
	Code        RpcBlockExportResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockExportResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockExportResponseError proto.InternalMessageInfo

func (m *RpcBlockExportResponseError) GetCode() RpcBlockExportResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockExportResponseError_NULL
}

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

type RpcBlockUpload struct {
}

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

var xxx_messageInfo_RpcBlockUpload proto.InternalMessageInfo

type RpcBlockUploadRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	FilePath  string `protobuf:"bytes,3,opt,name=filePath,proto3" json:"filePath,omitempty"`
	Url       string `protobuf:"bytes,4,opt,name=url,proto3" json:"url,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUploadRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockUploadRequest) GetFilePath() string {
	if m != nil {
		return m.FilePath
	}
	return ""
}

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

type RpcBlockUploadResponse struct {
	Error *RpcBlockUploadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent               `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUploadResponse proto.InternalMessageInfo

func (m *RpcBlockUploadResponse) GetError() *RpcBlockUploadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockUploadResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockUploadResponseError struct {
	Code        RpcBlockUploadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockUploadResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUploadResponseError proto.InternalMessageInfo

func (m *RpcBlockUploadResponseError) GetCode() RpcBlockUploadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockUploadResponseError_NULL
}

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

type RpcBlockDownload struct {
}

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

var xxx_messageInfo_RpcBlockDownload proto.InternalMessageInfo

type RpcBlockDownloadRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDownloadRequest proto.InternalMessageInfo

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

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

type RpcBlockDownloadResponse struct {
	Error *RpcBlockDownloadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                 `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDownloadResponse proto.InternalMessageInfo

func (m *RpcBlockDownloadResponse) GetError() *RpcBlockDownloadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDownloadResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDownloadResponseError struct {
	Code        RpcBlockDownloadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDownloadResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDownloadResponseError proto.InternalMessageInfo

func (m *RpcBlockDownloadResponseError) GetCode() RpcBlockDownloadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDownloadResponseError_NULL
}

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

type RpcBlockSet struct {
}

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

var xxx_messageInfo_RpcBlockSet proto.InternalMessageInfo

type RpcBlockSetFields struct {
}

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

var xxx_messageInfo_RpcBlockSetFields proto.InternalMessageInfo

type RpcBlockSetFieldsRequest struct {
	ContextId string        `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string        `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Fields    *types.Struct `protobuf:"bytes,3,opt,name=fields,proto3" json:"fields,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetFieldsRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetFieldsResponse struct {
	Error *RpcBlockSetFieldsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                  `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetFieldsResponse proto.InternalMessageInfo

func (m *RpcBlockSetFieldsResponse) GetError() *RpcBlockSetFieldsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetFieldsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetFieldsResponseError struct {
	Code        RpcBlockSetFieldsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetFieldsResponseErrorCode" json:"code,omitempty"`
	Description string                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetFieldsResponseError proto.InternalMessageInfo

func (m *RpcBlockSetFieldsResponseError) GetCode() RpcBlockSetFieldsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetFieldsResponseError_NULL
}

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

type RpcBlockSetDetails struct {
}

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

var xxx_messageInfo_RpcBlockSetDetails proto.InternalMessageInfo

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

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

var xxx_messageInfo_RpcBlockSetDetailsDetail proto.InternalMessageInfo

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

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

type RpcBlockSetDetailsRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Details   []*RpcBlockSetDetailsDetail `protobuf:"bytes,2,rep,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetDetailsRequest proto.InternalMessageInfo

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

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

type RpcBlockSetDetailsResponse struct {
	Error *RpcBlockSetDetailsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                   `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetDetailsResponse proto.InternalMessageInfo

func (m *RpcBlockSetDetailsResponse) GetError() *RpcBlockSetDetailsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetDetailsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetDetailsResponseError struct {
	Code        RpcBlockSetDetailsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetDetailsResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetDetailsResponseError proto.InternalMessageInfo

func (m *RpcBlockSetDetailsResponseError) GetCode() RpcBlockSetDetailsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetDetailsResponseError_NULL
}

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

type RpcBlockSetRestrictions struct {
}

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

var xxx_messageInfo_RpcBlockSetRestrictions proto.InternalMessageInfo

type RpcBlockSetRestrictionsRequest struct {
	ContextId    string                   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId      string                   `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Restrictions *model.BlockRestrictions `protobuf:"bytes,3,opt,name=restrictions,proto3" json:"restrictions,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetRestrictionsRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetRestrictionsResponse struct {
	Error *RpcBlockSetRestrictionsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetRestrictionsResponse proto.InternalMessageInfo

func (m *RpcBlockSetRestrictionsResponse) GetError() *RpcBlockSetRestrictionsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetRestrictionsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetRestrictionsResponseError struct {
	Code        RpcBlockSetRestrictionsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetRestrictionsResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetRestrictionsResponseError proto.InternalMessageInfo

func (m *RpcBlockSetRestrictionsResponseError) GetCode() RpcBlockSetRestrictionsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetRestrictionsResponseError_NULL
}

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

type RpcBlockSetPage struct {
}

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

var xxx_messageInfo_RpcBlockSetPage proto.InternalMessageInfo

type RpcBlockSetPageIsArchived struct {
}

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

var xxx_messageInfo_RpcBlockSetPageIsArchived proto.InternalMessageInfo

type RpcBlockSetPageIsArchivedRequest struct {
	ContextId  string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId    string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	IsArchived bool   `protobuf:"varint,3,opt,name=isArchived,proto3" json:"isArchived,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetPageIsArchivedRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetPageIsArchivedResponse struct {
	Error *RpcBlockSetPageIsArchivedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetPageIsArchivedResponse proto.InternalMessageInfo

func (m *RpcBlockSetPageIsArchivedResponse) GetError() *RpcBlockSetPageIsArchivedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockSetPageIsArchivedResponseError struct {
	Code        RpcBlockSetPageIsArchivedResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetPageIsArchivedResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetPageIsArchivedResponseError proto.InternalMessageInfo

func (m *RpcBlockSetPageIsArchivedResponseError) GetCode() RpcBlockSetPageIsArchivedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetPageIsArchivedResponseError_NULL
}

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

type RpcBlockSetLatex struct {
}

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

var xxx_messageInfo_RpcBlockSetLatex proto.InternalMessageInfo

type RpcBlockSetLatexText struct {
}

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

var xxx_messageInfo_RpcBlockSetLatexText proto.InternalMessageInfo

type RpcBlockSetLatexTextRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Text      string `protobuf:"bytes,3,opt,name=text,proto3" json:"text,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetLatexTextRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetLatexTextResponse struct {
	Error *RpcBlockSetLatexTextResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetLatexTextResponse proto.InternalMessageInfo

func (m *RpcBlockSetLatexTextResponse) GetError() *RpcBlockSetLatexTextResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetLatexTextResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetLatexTextResponseError struct {
	Code        RpcBlockSetLatexTextResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetLatexTextResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetLatexTextResponseError proto.InternalMessageInfo

func (m *RpcBlockSetLatexTextResponseError) GetCode() RpcBlockSetLatexTextResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetLatexTextResponseError_NULL
}

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

type RpcBlockSetText struct {
}

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

var xxx_messageInfo_RpcBlockSetText proto.InternalMessageInfo

type RpcBlockSetTextText struct {
}

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

var xxx_messageInfo_RpcBlockSetTextText proto.InternalMessageInfo

type RpcBlockSetTextTextRequest struct {
	ContextId string                       `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string                       `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Text      string                       `protobuf:"bytes,3,opt,name=text,proto3" json:"text,omitempty"`
	Marks     *model.BlockContentTextMarks `protobuf:"bytes,4,opt,name=marks,proto3" json:"marks,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextTextRequest proto.InternalMessageInfo

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

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

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

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

type RpcBlockSetTextTextResponse struct {
	Error *RpcBlockSetTextTextResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextTextResponse proto.InternalMessageInfo

func (m *RpcBlockSetTextTextResponse) GetError() *RpcBlockSetTextTextResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetTextTextResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetTextTextResponseError struct {
	Code        RpcBlockSetTextTextResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetTextTextResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextTextResponseError proto.InternalMessageInfo

func (m *RpcBlockSetTextTextResponseError) GetCode() RpcBlockSetTextTextResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetTextTextResponseError_NULL
}

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

type RpcBlockSetTextColor struct {
}

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

var xxx_messageInfo_RpcBlockSetTextColor proto.InternalMessageInfo

type RpcBlockSetTextColorRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Color     string `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextColorRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetTextColorResponse struct {
	Error *RpcBlockSetTextColorResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextColorResponse proto.InternalMessageInfo

func (m *RpcBlockSetTextColorResponse) GetError() *RpcBlockSetTextColorResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetTextColorResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetTextColorResponseError struct {
	Code        RpcBlockSetTextColorResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetTextColorResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextColorResponseError proto.InternalMessageInfo

func (m *RpcBlockSetTextColorResponseError) GetCode() RpcBlockSetTextColorResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetTextColorResponseError_NULL
}

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

type RpcBlockSetTextStyle struct {
}

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

var xxx_messageInfo_RpcBlockSetTextStyle proto.InternalMessageInfo

type RpcBlockSetTextStyleRequest struct {
	ContextId string                      `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string                      `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Style     model.BlockContentTextStyle `protobuf:"varint,3,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle" json:"style,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextStyleRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetTextStyleResponse struct {
	Error *RpcBlockSetTextStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextStyleResponse proto.InternalMessageInfo

func (m *RpcBlockSetTextStyleResponse) GetError() *RpcBlockSetTextStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetTextStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetTextStyleResponseError struct {
	Code        RpcBlockSetTextStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetTextStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockSetTextStyleResponseError) GetCode() RpcBlockSetTextStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetTextStyleResponseError_NULL
}

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

type RpcBlockSetTextChecked struct {
}

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

var xxx_messageInfo_RpcBlockSetTextChecked proto.InternalMessageInfo

type RpcBlockSetTextCheckedRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Checked   bool   `protobuf:"varint,3,opt,name=checked,proto3" json:"checked,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextCheckedRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetTextCheckedResponse struct {
	Error *RpcBlockSetTextCheckedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextCheckedResponse proto.InternalMessageInfo

func (m *RpcBlockSetTextCheckedResponse) GetError() *RpcBlockSetTextCheckedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetTextCheckedResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetTextCheckedResponseError struct {
	Code        RpcBlockSetTextCheckedResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetTextCheckedResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextCheckedResponseError proto.InternalMessageInfo

func (m *RpcBlockSetTextCheckedResponseError) GetCode() RpcBlockSetTextCheckedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetTextCheckedResponseError_NULL
}

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

type RpcBlockSetTextIcon struct {
}

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

var xxx_messageInfo_RpcBlockSetTextIcon proto.InternalMessageInfo

type RpcBlockSetTextIconRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	IconImage string `protobuf:"bytes,3,opt,name=iconImage,proto3" json:"iconImage,omitempty"`
	IconEmoji string `protobuf:"bytes,5,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextIconRequest proto.InternalMessageInfo

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

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

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

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

type RpcBlockSetTextIconResponse struct {
	Error *RpcBlockSetTextIconResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextIconResponse proto.InternalMessageInfo

func (m *RpcBlockSetTextIconResponse) GetError() *RpcBlockSetTextIconResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetTextIconResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetTextIconResponseError struct {
	Code        RpcBlockSetTextIconResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetTextIconResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetTextIconResponseError proto.InternalMessageInfo

func (m *RpcBlockSetTextIconResponseError) GetCode() RpcBlockSetTextIconResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetTextIconResponseError_NULL
}

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

type RpcBlockSetFile struct {
}

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

var xxx_messageInfo_RpcBlockSetFile proto.InternalMessageInfo

type RpcBlockSetFileName struct {
}

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

var xxx_messageInfo_RpcBlockSetFileName proto.InternalMessageInfo

type RpcBlockSetFileNameRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Name      string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetFileNameRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetFileNameResponse struct {
	Error *RpcBlockSetFileNameResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetFileNameResponse proto.InternalMessageInfo

func (m *RpcBlockSetFileNameResponse) GetError() *RpcBlockSetFileNameResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetFileNameResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetFileNameResponseError struct {
	Code        RpcBlockSetFileNameResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetFileNameResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetFileNameResponseError proto.InternalMessageInfo

func (m *RpcBlockSetFileNameResponseError) GetCode() RpcBlockSetFileNameResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetFileNameResponseError_NULL
}

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

type RpcBlockSetImage struct {
}

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

var xxx_messageInfo_RpcBlockSetImage proto.InternalMessageInfo

type RpcBlockSetImageName struct {
}

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

var xxx_messageInfo_RpcBlockSetImageName proto.InternalMessageInfo

type RpcBlockSetImageNameRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Name      string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetImageNameRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetImageNameResponse struct {
	Error *RpcBlockSetImageNameResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetImageNameResponse proto.InternalMessageInfo

func (m *RpcBlockSetImageNameResponse) GetError() *RpcBlockSetImageNameResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockSetImageNameResponseError struct {
	Code        RpcBlockSetImageNameResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetImageNameResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetImageNameResponseError proto.InternalMessageInfo

func (m *RpcBlockSetImageNameResponseError) GetCode() RpcBlockSetImageNameResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetImageNameResponseError_NULL
}

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

type RpcBlockSetImageWidth struct {
}

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

var xxx_messageInfo_RpcBlockSetImageWidth proto.InternalMessageInfo

type RpcBlockSetImageWidthRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Width     int32  `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetImageWidthRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetImageWidthResponse struct {
	Error *RpcBlockSetImageWidthResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetImageWidthResponse proto.InternalMessageInfo

func (m *RpcBlockSetImageWidthResponse) GetError() *RpcBlockSetImageWidthResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockSetImageWidthResponseError struct {
	Code        RpcBlockSetImageWidthResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetImageWidthResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetImageWidthResponseError proto.InternalMessageInfo

func (m *RpcBlockSetImageWidthResponseError) GetCode() RpcBlockSetImageWidthResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetImageWidthResponseError_NULL
}

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

type RpcBlockSetVideo struct {
}

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

var xxx_messageInfo_RpcBlockSetVideo proto.InternalMessageInfo

type RpcBlockSetVideoName struct {
}

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

var xxx_messageInfo_RpcBlockSetVideoName proto.InternalMessageInfo

type RpcBlockSetVideoNameRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Name      string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetVideoNameRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetVideoNameResponse struct {
	Error *RpcBlockSetVideoNameResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetVideoNameResponse proto.InternalMessageInfo

func (m *RpcBlockSetVideoNameResponse) GetError() *RpcBlockSetVideoNameResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockSetVideoNameResponseError struct {
	Code        RpcBlockSetVideoNameResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetVideoNameResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetVideoNameResponseError proto.InternalMessageInfo

func (m *RpcBlockSetVideoNameResponseError) GetCode() RpcBlockSetVideoNameResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetVideoNameResponseError_NULL
}

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

type RpcBlockSetVideoWidth struct {
}

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

var xxx_messageInfo_RpcBlockSetVideoWidth proto.InternalMessageInfo

type RpcBlockSetVideoWidthRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Width     int32  `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetVideoWidthRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetVideoWidthResponse struct {
	Error *RpcBlockSetVideoWidthResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetVideoWidthResponse proto.InternalMessageInfo

func (m *RpcBlockSetVideoWidthResponse) GetError() *RpcBlockSetVideoWidthResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockSetVideoWidthResponseError struct {
	Code        RpcBlockSetVideoWidthResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetVideoWidthResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetVideoWidthResponseError proto.InternalMessageInfo

func (m *RpcBlockSetVideoWidthResponseError) GetCode() RpcBlockSetVideoWidthResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetVideoWidthResponseError_NULL
}

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

type RpcBlockSetLink struct {
}

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

var xxx_messageInfo_RpcBlockSetLink proto.InternalMessageInfo

type RpcBlockSetLinkTargetBlockId struct {
}

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

var xxx_messageInfo_RpcBlockSetLinkTargetBlockId proto.InternalMessageInfo

type RpcBlockSetLinkTargetBlockIdRequest struct {
	ContextId     string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId       string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	TargetBlockId string `protobuf:"bytes,3,opt,name=targetBlockId,proto3" json:"targetBlockId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetLinkTargetBlockIdRequest proto.InternalMessageInfo

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

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

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

type RpcBlockSetLinkTargetBlockIdResponse struct {
	Error *RpcBlockSetLinkTargetBlockIdResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetLinkTargetBlockIdResponse proto.InternalMessageInfo

func (m *RpcBlockSetLinkTargetBlockIdResponse) GetError() *RpcBlockSetLinkTargetBlockIdResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetLinkTargetBlockIdResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetLinkTargetBlockIdResponseError struct {
	Code        RpcBlockSetLinkTargetBlockIdResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetLinkTargetBlockIdResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockSetLinkTargetBlockIdResponseError proto.InternalMessageInfo

func (m *RpcBlockSetLinkTargetBlockIdResponseError) GetCode() RpcBlockSetLinkTargetBlockIdResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetLinkTargetBlockIdResponseError_NULL
}

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

type RpcBlockRelation struct {
}

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

var xxx_messageInfo_RpcBlockRelation proto.InternalMessageInfo

type RpcBlockRelationSetKey struct {
}

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

var xxx_messageInfo_RpcBlockRelationSetKey proto.InternalMessageInfo

type RpcBlockRelationSetKeyRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Key       string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_RpcBlockRelationSetKeyRequest proto.InternalMessageInfo

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

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

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

type RpcBlockRelationSetKeyResponse struct {
	Error *RpcBlockRelationSetKeyResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockRelationSetKeyResponse proto.InternalMessageInfo

func (m *RpcBlockRelationSetKeyResponse) GetError() *RpcBlockRelationSetKeyResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockRelationSetKeyResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockRelationSetKeyResponseError struct {
	Code        RpcBlockRelationSetKeyResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockRelationSetKeyResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockRelationSetKeyResponseError proto.InternalMessageInfo

func (m *RpcBlockRelationSetKeyResponseError) GetCode() RpcBlockRelationSetKeyResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockRelationSetKeyResponseError_NULL
}

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

type RpcBlockRelationAdd struct {
}

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

var xxx_messageInfo_RpcBlockRelationAdd proto.InternalMessageInfo

type RpcBlockRelationAddRequest struct {
	ContextId string          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string          `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Relation  *model.Relation `protobuf:"bytes,3,opt,name=relation,proto3" json:"relation,omitempty"`
}

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

var xxx_messageInfo_RpcBlockRelationAddRequest proto.InternalMessageInfo

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

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

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

type RpcBlockRelationAddResponse struct {
	Error *RpcBlockRelationAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockRelationAddResponse proto.InternalMessageInfo

func (m *RpcBlockRelationAddResponse) GetError() *RpcBlockRelationAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockRelationAddResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockRelationAddResponseError struct {
	Code        RpcBlockRelationAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockRelationAddResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockRelationAddResponseError proto.InternalMessageInfo

func (m *RpcBlockRelationAddResponseError) GetCode() RpcBlockRelationAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockRelationAddResponseError_NULL
}

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

type RpcBlockObjectType struct {
}

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

var xxx_messageInfo_RpcBlockObjectType proto.InternalMessageInfo

type RpcBlockObjectTypeSet struct {
}

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

var xxx_messageInfo_RpcBlockObjectTypeSet proto.InternalMessageInfo

type RpcBlockObjectTypeSetRequest struct {
	ContextId     string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	ObjectTypeUrl string `protobuf:"bytes,3,opt,name=objectTypeUrl,proto3" json:"objectTypeUrl,omitempty"`
}

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

var xxx_messageInfo_RpcBlockObjectTypeSetRequest proto.InternalMessageInfo

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

func (m *RpcBlockObjectTypeSetRequest) GetObjectTypeUrl() string {
	if m != nil {
		return m.ObjectTypeUrl
	}
	return ""
}

type RpcBlockObjectTypeSetResponse struct {
	Error *RpcBlockObjectTypeSetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                      `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockObjectTypeSetResponse proto.InternalMessageInfo

func (m *RpcBlockObjectTypeSetResponse) GetError() *RpcBlockObjectTypeSetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockObjectTypeSetResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockObjectTypeSetResponseError struct {
	Code        RpcBlockObjectTypeSetResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockObjectTypeSetResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockObjectTypeSetResponseError proto.InternalMessageInfo

func (m *RpcBlockObjectTypeSetResponseError) GetCode() RpcBlockObjectTypeSetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockObjectTypeSetResponseError_NULL
}

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

type RpcBlockBookmark struct {
}

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

var xxx_messageInfo_RpcBlockBookmark proto.InternalMessageInfo

type RpcBlockBookmarkFetch struct {
}

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

var xxx_messageInfo_RpcBlockBookmarkFetch proto.InternalMessageInfo

type RpcBlockBookmarkFetchRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Url       string `protobuf:"bytes,3,opt,name=url,proto3" json:"url,omitempty"`
}

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

var xxx_messageInfo_RpcBlockBookmarkFetchRequest proto.InternalMessageInfo

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

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

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

type RpcBlockBookmarkFetchResponse struct {
	Error *RpcBlockBookmarkFetchResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                      `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockBookmarkFetchResponse proto.InternalMessageInfo

func (m *RpcBlockBookmarkFetchResponse) GetError() *RpcBlockBookmarkFetchResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockBookmarkFetchResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockBookmarkFetchResponseError struct {
	Code        RpcBlockBookmarkFetchResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockBookmarkFetchResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockBookmarkFetchResponseError proto.InternalMessageInfo

func (m *RpcBlockBookmarkFetchResponseError) GetCode() RpcBlockBookmarkFetchResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockBookmarkFetchResponseError_NULL
}

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

type RpcBlockBookmarkCreateAndFetch struct {
}

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

var xxx_messageInfo_RpcBlockBookmarkCreateAndFetch proto.InternalMessageInfo

type RpcBlockBookmarkCreateAndFetchRequest struct {
	ContextId string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TargetId  string              `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position  model.BlockPosition `protobuf:"varint,3,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	Url       string              `protobuf:"bytes,4,opt,name=url,proto3" json:"url,omitempty"`
}

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

var xxx_messageInfo_RpcBlockBookmarkCreateAndFetchRequest proto.InternalMessageInfo

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

func (m *RpcBlockBookmarkCreateAndFetchRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockBookmarkCreateAndFetchRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

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

type RpcBlockBookmarkCreateAndFetchResponse struct {
	Error   *RpcBlockBookmarkCreateAndFetchResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId string                                       `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Event   *ResponseEvent                               `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockBookmarkCreateAndFetchResponse proto.InternalMessageInfo

func (m *RpcBlockBookmarkCreateAndFetchResponse) GetError() *RpcBlockBookmarkCreateAndFetchResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockBookmarkCreateAndFetchResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockBookmarkCreateAndFetchResponseError struct {
	Code        RpcBlockBookmarkCreateAndFetchResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockBookmarkCreateAndFetchResponseErrorCode" json:"code,omitempty"`
	Description string                                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockBookmarkCreateAndFetchResponseError proto.InternalMessageInfo

func (m *RpcBlockBookmarkCreateAndFetchResponseError) GetCode() RpcBlockBookmarkCreateAndFetchResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockBookmarkCreateAndFetchResponseError_NULL
}

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

type RpcBlockFile struct {
}

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

var xxx_messageInfo_RpcBlockFile proto.InternalMessageInfo

type RpcBlockFileCreateAndUpload struct {
}

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

var xxx_messageInfo_RpcBlockFileCreateAndUpload proto.InternalMessageInfo

type RpcBlockFileCreateAndUploadRequest struct {
	ContextId string                     `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TargetId  string                     `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position  model.BlockPosition        `protobuf:"varint,3,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	Url       string                     `protobuf:"bytes,4,opt,name=url,proto3" json:"url,omitempty"`
	LocalPath string                     `protobuf:"bytes,5,opt,name=localPath,proto3" json:"localPath,omitempty"`
	FileType  model.BlockContentFileType `protobuf:"varint,6,opt,name=fileType,proto3,enum=anytype.model.BlockContentFileType" json:"fileType,omitempty"`
}

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

var xxx_messageInfo_RpcBlockFileCreateAndUploadRequest proto.InternalMessageInfo

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

func (m *RpcBlockFileCreateAndUploadRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockFileCreateAndUploadRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

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

func (m *RpcBlockFileCreateAndUploadRequest) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

func (m *RpcBlockFileCreateAndUploadRequest) GetFileType() model.BlockContentFileType {
	if m != nil {
		return m.FileType
	}
	return model.BlockContentFile_None
}

type RpcBlockFileCreateAndUploadResponse struct {
	Error   *RpcBlockFileCreateAndUploadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId string                                    `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Event   *ResponseEvent                            `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockFileCreateAndUploadResponse proto.InternalMessageInfo

func (m *RpcBlockFileCreateAndUploadResponse) GetError() *RpcBlockFileCreateAndUploadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockFileCreateAndUploadResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockFileCreateAndUploadResponseError struct {
	Code        RpcBlockFileCreateAndUploadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockFileCreateAndUploadResponseErrorCode" json:"code,omitempty"`
	Description string                                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockFileCreateAndUploadResponseError proto.InternalMessageInfo

func (m *RpcBlockFileCreateAndUploadResponseError) GetCode() RpcBlockFileCreateAndUploadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockFileCreateAndUploadResponseError_NULL
}

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

type RpcBlockDataview struct {
}

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

var xxx_messageInfo_RpcBlockDataview proto.InternalMessageInfo

type RpcBlockDataviewViewCreate struct {
}

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

var xxx_messageInfo_RpcBlockDataviewViewCreate proto.InternalMessageInfo

type RpcBlockDataviewViewCreateRequest struct {
	ContextId string                          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string                          `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	View      *model.BlockContentDataviewView `protobuf:"bytes,4,opt,name=view,proto3" json:"view,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewCreateRequest proto.InternalMessageInfo

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

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

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

type RpcBlockDataviewViewCreateResponse struct {
	Error  *RpcBlockDataviewViewCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event  *ResponseEvent                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	ViewId string                                   `protobuf:"bytes,3,opt,name=viewId,proto3" json:"viewId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewCreateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewViewCreateResponse) GetError() *RpcBlockDataviewViewCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewViewCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

type RpcBlockDataviewViewCreateResponseError struct {
	Code        RpcBlockDataviewViewCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewViewCreateResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewCreateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewViewCreateResponseError) GetCode() RpcBlockDataviewViewCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewViewCreateResponseError_NULL
}

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

type RpcBlockDataviewViewUpdate struct {
}

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

var xxx_messageInfo_RpcBlockDataviewViewUpdate proto.InternalMessageInfo

type RpcBlockDataviewViewUpdateRequest struct {
	ContextId string                          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string                          `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	ViewId    string                          `protobuf:"bytes,3,opt,name=viewId,proto3" json:"viewId,omitempty"`
	View      *model.BlockContentDataviewView `protobuf:"bytes,4,opt,name=view,proto3" json:"view,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewUpdateRequest proto.InternalMessageInfo

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

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

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

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

type RpcBlockDataviewViewUpdateResponse struct {
	Error *RpcBlockDataviewViewUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewViewUpdateResponse) GetError() *RpcBlockDataviewViewUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewViewUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewViewUpdateResponseError struct {
	Code        RpcBlockDataviewViewUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewViewUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewViewUpdateResponseError) GetCode() RpcBlockDataviewViewUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewViewUpdateResponseError_NULL
}

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

type RpcBlockDataviewViewDelete struct {
}

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

var xxx_messageInfo_RpcBlockDataviewViewDelete proto.InternalMessageInfo

type RpcBlockDataviewViewDeleteRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	ViewId    string `protobuf:"bytes,4,opt,name=viewId,proto3" json:"viewId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewDeleteRequest proto.InternalMessageInfo

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

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

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

type RpcBlockDataviewViewDeleteResponse struct {
	Error *RpcBlockDataviewViewDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewViewDeleteResponse) GetError() *RpcBlockDataviewViewDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewViewDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewViewDeleteResponseError struct {
	Code        RpcBlockDataviewViewDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewViewDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewViewDeleteResponseError) GetCode() RpcBlockDataviewViewDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewViewDeleteResponseError_NULL
}

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

type RpcBlockDataviewViewSetPosition struct {
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetPosition proto.InternalMessageInfo

type RpcBlockDataviewViewSetPositionRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	ViewId    string `protobuf:"bytes,4,opt,name=viewId,proto3" json:"viewId,omitempty"`
	Position  uint32 `protobuf:"varint,5,opt,name=position,proto3" json:"position,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetPositionRequest proto.InternalMessageInfo

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

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

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

func (m *RpcBlockDataviewViewSetPositionRequest) GetPosition() uint32 {
	if m != nil {
		return m.Position
	}
	return 0
}

type RpcBlockDataviewViewSetPositionResponse struct {
	Error *RpcBlockDataviewViewSetPositionResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetPositionResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewViewSetPositionResponse) GetError() *RpcBlockDataviewViewSetPositionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewViewSetPositionResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewViewSetPositionResponseError struct {
	Code        RpcBlockDataviewViewSetPositionResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewViewSetPositionResponseErrorCode" json:"code,omitempty"`
	Description string                                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetPositionResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewViewSetPositionResponseError) GetCode() RpcBlockDataviewViewSetPositionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewViewSetPositionResponseError_NULL
}

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

// set the current active view (persisted only within a session)
type RpcBlockDataviewViewSetActive struct {
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetActive proto.InternalMessageInfo

type RpcBlockDataviewViewSetActiveRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	ViewId    string `protobuf:"bytes,3,opt,name=viewId,proto3" json:"viewId,omitempty"`
	Offset    uint32 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit     uint32 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetActiveRequest proto.InternalMessageInfo

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

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

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

func (m *RpcBlockDataviewViewSetActiveRequest) GetOffset() uint32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

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

type RpcBlockDataviewViewSetActiveResponse struct {
	Error *RpcBlockDataviewViewSetActiveResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetActiveResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewViewSetActiveResponse) GetError() *RpcBlockDataviewViewSetActiveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewViewSetActiveResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewViewSetActiveResponseError struct {
	Code        RpcBlockDataviewViewSetActiveResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewViewSetActiveResponseErrorCode" json:"code,omitempty"`
	Description string                                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewViewSetActiveResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewViewSetActiveResponseError) GetCode() RpcBlockDataviewViewSetActiveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewViewSetActiveResponseError_NULL
}

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

type RpcBlockDataviewRecordUpdate struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRecordUpdate proto.InternalMessageInfo

type RpcBlockDataviewRecordUpdateRequest struct {
	ContextId string        `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string        `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RecordId  string        `protobuf:"bytes,3,opt,name=recordId,proto3" json:"recordId,omitempty"`
	Record    *types.Struct `protobuf:"bytes,4,opt,name=record,proto3" json:"record,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordUpdateRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockDataviewRecordUpdateRequest) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

func (m *RpcBlockDataviewRecordUpdateRequest) GetRecord() *types.Struct {
	if m != nil {
		return m.Record
	}
	return nil
}

type RpcBlockDataviewRecordUpdateResponse struct {
	Error *RpcBlockDataviewRecordUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordUpdateResponse) GetError() *RpcBlockDataviewRecordUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockDataviewRecordUpdateResponseError struct {
	Code        RpcBlockDataviewRecordUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRecordUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordUpdateResponseError) GetCode() RpcBlockDataviewRecordUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRecordUpdateResponseError_NULL
}

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

type RpcBlockDataviewRecordDelete struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRecordDelete proto.InternalMessageInfo

type RpcBlockDataviewRecordDeleteRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RecordId  string `protobuf:"bytes,3,opt,name=recordId,proto3" json:"recordId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordDeleteRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockDataviewRecordDeleteRequest) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

type RpcBlockDataviewRecordDeleteResponse struct {
	Error *RpcBlockDataviewRecordDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordDeleteResponse) GetError() *RpcBlockDataviewRecordDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRecordDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewRecordDeleteResponseError struct {
	Code        RpcBlockDataviewRecordDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRecordDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordDeleteResponseError) GetCode() RpcBlockDataviewRecordDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRecordDeleteResponseError_NULL
}

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

type RpcBlockDataviewRecordCreate struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRecordCreate proto.InternalMessageInfo

type RpcBlockDataviewRecordCreateRequest struct {
	ContextId  string        `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId    string        `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Record     *types.Struct `protobuf:"bytes,3,opt,name=record,proto3" json:"record,omitempty"`
	TemplateId string        `protobuf:"bytes,4,opt,name=templateId,proto3" json:"templateId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordCreateRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockDataviewRecordCreateRequest) GetRecord() *types.Struct {
	if m != nil {
		return m.Record
	}
	return nil
}

func (m *RpcBlockDataviewRecordCreateRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

type RpcBlockDataviewRecordCreateResponse struct {
	Error  *RpcBlockDataviewRecordCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Record *types.Struct                              `protobuf:"bytes,2,opt,name=record,proto3" json:"record,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordCreateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordCreateResponse) GetError() *RpcBlockDataviewRecordCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRecordCreateResponse) GetRecord() *types.Struct {
	if m != nil {
		return m.Record
	}
	return nil
}

type RpcBlockDataviewRecordCreateResponseError struct {
	Code        RpcBlockDataviewRecordCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRecordCreateResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordCreateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordCreateResponseError) GetCode() RpcBlockDataviewRecordCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRecordCreateResponseError_NULL
}

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

type RpcBlockDataviewRelationAdd struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRelationAdd proto.InternalMessageInfo

type RpcBlockDataviewRelationAddRequest struct {
	ContextId string          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string          `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Relation  *model.Relation `protobuf:"bytes,3,opt,name=relation,proto3" json:"relation,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationAddRequest proto.InternalMessageInfo

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

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

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

type RpcBlockDataviewRelationAddResponse struct {
	Error       *RpcBlockDataviewRelationAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event       *ResponseEvent                            `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	RelationKey string                                    `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Relation    *model.Relation                           `protobuf:"bytes,4,opt,name=relation,proto3" json:"relation,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationAddResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationAddResponse) GetError() *RpcBlockDataviewRelationAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRelationAddResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

type RpcBlockDataviewRelationAddResponseError struct {
	Code        RpcBlockDataviewRelationAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRelationAddResponseErrorCode" json:"code,omitempty"`
	Description string                                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationAddResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationAddResponseError) GetCode() RpcBlockDataviewRelationAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRelationAddResponseError_NULL
}

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

type RpcBlockDataviewRelationUpdate struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRelationUpdate proto.InternalMessageInfo

type RpcBlockDataviewRelationUpdateRequest struct {
	ContextId   string          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId     string          `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RelationKey string          `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Relation    *model.Relation `protobuf:"bytes,4,opt,name=relation,proto3" json:"relation,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationUpdateRequest proto.InternalMessageInfo

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

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

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

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

type RpcBlockDataviewRelationUpdateResponse struct {
	Error *RpcBlockDataviewRelationUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                               `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationUpdateResponse) GetError() *RpcBlockDataviewRelationUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRelationUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewRelationUpdateResponseError struct {
	Code        RpcBlockDataviewRelationUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRelationUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationUpdateResponseError) GetCode() RpcBlockDataviewRelationUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRelationUpdateResponseError_NULL
}

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

type RpcBlockDataviewRelationDelete struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRelationDelete proto.InternalMessageInfo

type RpcBlockDataviewRelationDeleteRequest struct {
	ContextId   string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId     string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RelationKey string `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationDeleteRequest proto.InternalMessageInfo

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

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

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

type RpcBlockDataviewRelationDeleteResponse struct {
	Error *RpcBlockDataviewRelationDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                               `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationDeleteResponse) GetError() *RpcBlockDataviewRelationDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRelationDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewRelationDeleteResponseError struct {
	Code        RpcBlockDataviewRelationDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRelationDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRelationDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationDeleteResponseError) GetCode() RpcBlockDataviewRelationDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRelationDeleteResponseError_NULL
}

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

// RecordRelationOptionAdd may return existing option in case object specified with recordId already have the option with the same name or ID
type RpcBlockDataviewRecordRelationOptionAdd struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionAdd proto.InternalMessageInfo

type RpcBlockDataviewRecordRelationOptionAddRequest struct {
	ContextId   string                `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId     string                `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RelationKey string                `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Option      *model.RelationOption `protobuf:"bytes,4,opt,name=option,proto3" json:"option,omitempty"`
	RecordId    string                `protobuf:"bytes,5,opt,name=recordId,proto3" json:"recordId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionAddRequest proto.InternalMessageInfo

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

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

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

func (m *RpcBlockDataviewRecordRelationOptionAddRequest) GetOption() *model.RelationOption {
	if m != nil {
		return m.Option
	}
	return nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddRequest) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

type RpcBlockDataviewRecordRelationOptionAddResponse struct {
	Error  *RpcBlockDataviewRecordRelationOptionAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event  *ResponseEvent                                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	Option *model.RelationOption                                 `protobuf:"bytes,3,opt,name=option,proto3" json:"option,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionAddResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) GetError() *RpcBlockDataviewRecordRelationOptionAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) GetOption() *model.RelationOption {
	if m != nil {
		return m.Option
	}
	return nil
}

type RpcBlockDataviewRecordRelationOptionAddResponseError struct {
	Code        RpcBlockDataviewRecordRelationOptionAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRecordRelationOptionAddResponseErrorCode" json:"code,omitempty"`
	Description string                                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionAddResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionAddResponseError) GetCode() RpcBlockDataviewRecordRelationOptionAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRecordRelationOptionAddResponseError_NULL
}

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

type RpcBlockDataviewRecordRelationOptionUpdate struct {
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionUpdate proto.InternalMessageInfo

type RpcBlockDataviewRecordRelationOptionUpdateRequest struct {
	ContextId   string                `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId     string                `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RelationKey string                `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Option      *model.RelationOption `protobuf:"bytes,4,opt,name=option,proto3" json:"option,omitempty"`
	RecordId    string                `protobuf:"bytes,5,opt,name=recordId,proto3" json:"recordId,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionUpdateRequest proto.InternalMessageInfo

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

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

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

func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) GetOption() *model.RelationOption {
	if m != nil {
		return m.Option
	}
	return nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

type RpcBlockDataviewRecordRelationOptionUpdateResponse struct {
	Error *RpcBlockDataviewRecordRelationOptionUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) GetError() *RpcBlockDataviewRecordRelationOptionUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewRecordRelationOptionUpdateResponseError struct {
	Code        RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

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

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) GetCode() RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRecordRelationOptionUpdateResponseError_NULL
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockDataviewRecordRelationOptionDelete struct {
}

func (m *RpcBlockDataviewRecordRelationOptionDelete) Reset() {
	*m = RpcBlockDataviewRecordRelationOptionDelete{}
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRecordRelationOptionDelete) ProtoMessage() {}
func (*RpcBlockDataviewRecordRelationOptionDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 13}
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDelete.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDelete.Merge(m, src)
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDelete.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDelete proto.InternalMessageInfo

type RpcBlockDataviewRecordRelationOptionDeleteRequest struct {
	ContextId   string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId     string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	RelationKey string `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	OptionId    string `protobuf:"bytes,4,opt,name=optionId,proto3" json:"optionId,omitempty"`
	RecordId    string `protobuf:"bytes,5,opt,name=recordId,proto3" json:"recordId,omitempty"`
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) Reset() {
	*m = RpcBlockDataviewRecordRelationOptionDeleteRequest{}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRecordRelationOptionDeleteRequest) ProtoMessage() {}
func (*RpcBlockDataviewRecordRelationOptionDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 13, 0}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteRequest.Merge(m, src)
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteRequest proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) GetOptionId() string {
	if m != nil {
		return m.OptionId
	}
	return ""
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) GetRecordId() string {
	if m != nil {
		return m.RecordId
	}
	return ""
}

type RpcBlockDataviewRecordRelationOptionDeleteResponse struct {
	Error *RpcBlockDataviewRecordRelationOptionDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) Reset() {
	*m = RpcBlockDataviewRecordRelationOptionDeleteResponse{}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRecordRelationOptionDeleteResponse) ProtoMessage() {}
func (*RpcBlockDataviewRecordRelationOptionDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 13, 1}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponse.Merge(m, src)
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) GetError() *RpcBlockDataviewRecordRelationOptionDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewRecordRelationOptionDeleteResponseError struct {
	Code        RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) Reset() {
	*m = RpcBlockDataviewRecordRelationOptionDeleteResponseError{}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRecordRelationOptionDeleteResponseError) ProtoMessage() {}
func (*RpcBlockDataviewRecordRelationOptionDeleteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 13, 1, 0}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponseError.Merge(m, src)
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRecordRelationOptionDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) GetCode() RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRecordRelationOptionDeleteResponseError_NULL
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockDataviewRelationListAvailable struct {
}

func (m *RpcBlockDataviewRelationListAvailable) Reset()         { *m = RpcBlockDataviewRelationListAvailable{} }
func (m *RpcBlockDataviewRelationListAvailable) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewRelationListAvailable) ProtoMessage()    {}
func (*RpcBlockDataviewRelationListAvailable) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 14}
}
func (m *RpcBlockDataviewRelationListAvailable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRelationListAvailable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRelationListAvailable.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRelationListAvailable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailable.Merge(m, src)
}
func (m *RpcBlockDataviewRelationListAvailable) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRelationListAvailable) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailable.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRelationListAvailable proto.InternalMessageInfo

type RpcBlockDataviewRelationListAvailableRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
}

func (m *RpcBlockDataviewRelationListAvailableRequest) Reset() {
	*m = RpcBlockDataviewRelationListAvailableRequest{}
}
func (m *RpcBlockDataviewRelationListAvailableRequest) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRelationListAvailableRequest) ProtoMessage() {}
func (*RpcBlockDataviewRelationListAvailableRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 14, 0}
}
func (m *RpcBlockDataviewRelationListAvailableRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRelationListAvailableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRelationListAvailableRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRelationListAvailableRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailableRequest.Merge(m, src)
}
func (m *RpcBlockDataviewRelationListAvailableRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRelationListAvailableRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailableRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRelationListAvailableRequest proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationListAvailableRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDataviewRelationListAvailableRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

type RpcBlockDataviewRelationListAvailableResponse struct {
	Error     *RpcBlockDataviewRelationListAvailableResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Relations []*model.Relation                                   `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcBlockDataviewRelationListAvailableResponse) Reset() {
	*m = RpcBlockDataviewRelationListAvailableResponse{}
}
func (m *RpcBlockDataviewRelationListAvailableResponse) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRelationListAvailableResponse) ProtoMessage() {}
func (*RpcBlockDataviewRelationListAvailableResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 14, 1}
}
func (m *RpcBlockDataviewRelationListAvailableResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRelationListAvailableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRelationListAvailableResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponse.Merge(m, src)
}
func (m *RpcBlockDataviewRelationListAvailableResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRelationListAvailableResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationListAvailableResponse) GetError() *RpcBlockDataviewRelationListAvailableResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewRelationListAvailableResponse) GetRelations() []*model.Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcBlockDataviewRelationListAvailableResponseError struct {
	Code        RpcBlockDataviewRelationListAvailableResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewRelationListAvailableResponseErrorCode" json:"code,omitempty"`
	Description string                                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDataviewRelationListAvailableResponseError) Reset() {
	*m = RpcBlockDataviewRelationListAvailableResponseError{}
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewRelationListAvailableResponseError) ProtoMessage() {}
func (*RpcBlockDataviewRelationListAvailableResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 14, 1, 0}
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponseError.Merge(m, src)
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRelationListAvailableResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewRelationListAvailableResponseError) GetCode() RpcBlockDataviewRelationListAvailableResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewRelationListAvailableResponseError_NULL
}

func (m *RpcBlockDataviewRelationListAvailableResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockDataviewSetSource struct {
}

func (m *RpcBlockDataviewSetSource) Reset()         { *m = RpcBlockDataviewSetSource{} }
func (m *RpcBlockDataviewSetSource) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewSetSource) ProtoMessage()    {}
func (*RpcBlockDataviewSetSource) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 15}
}
func (m *RpcBlockDataviewSetSource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewSetSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewSetSource.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewSetSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewSetSource.Merge(m, src)
}
func (m *RpcBlockDataviewSetSource) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewSetSource) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewSetSource.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewSetSource proto.InternalMessageInfo

type RpcBlockDataviewSetSourceRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string   `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Source    []string `protobuf:"bytes,3,rep,name=source,proto3" json:"source,omitempty"`
}

func (m *RpcBlockDataviewSetSourceRequest) Reset()         { *m = RpcBlockDataviewSetSourceRequest{} }
func (m *RpcBlockDataviewSetSourceRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewSetSourceRequest) ProtoMessage()    {}
func (*RpcBlockDataviewSetSourceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 15, 0}
}
func (m *RpcBlockDataviewSetSourceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewSetSourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewSetSourceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewSetSourceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewSetSourceRequest.Merge(m, src)
}
func (m *RpcBlockDataviewSetSourceRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewSetSourceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewSetSourceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewSetSourceRequest proto.InternalMessageInfo

func (m *RpcBlockDataviewSetSourceRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDataviewSetSourceRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockDataviewSetSourceRequest) GetSource() []string {
	if m != nil {
		return m.Source
	}
	return nil
}

type RpcBlockDataviewSetSourceResponse struct {
	Error *RpcBlockDataviewSetSourceResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockDataviewSetSourceResponse) Reset()         { *m = RpcBlockDataviewSetSourceResponse{} }
func (m *RpcBlockDataviewSetSourceResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewSetSourceResponse) ProtoMessage()    {}
func (*RpcBlockDataviewSetSourceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 15, 1}
}
func (m *RpcBlockDataviewSetSourceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewSetSourceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewSetSourceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewSetSourceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewSetSourceResponse.Merge(m, src)
}
func (m *RpcBlockDataviewSetSourceResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewSetSourceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewSetSourceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewSetSourceResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewSetSourceResponse) GetError() *RpcBlockDataviewSetSourceResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewSetSourceResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewSetSourceResponseError struct {
	Code        RpcBlockDataviewSetSourceResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewSetSourceResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDataviewSetSourceResponseError) Reset() {
	*m = RpcBlockDataviewSetSourceResponseError{}
}
func (m *RpcBlockDataviewSetSourceResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewSetSourceResponseError) ProtoMessage()    {}
func (*RpcBlockDataviewSetSourceResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 16, 15, 1, 0}
}
func (m *RpcBlockDataviewSetSourceResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewSetSourceResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewSetSourceResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewSetSourceResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewSetSourceResponseError.Merge(m, src)
}
func (m *RpcBlockDataviewSetSourceResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewSetSourceResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewSetSourceResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewSetSourceResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewSetSourceResponseError) GetCode() RpcBlockDataviewSetSourceResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewSetSourceResponseError_NULL
}

func (m *RpcBlockDataviewSetSourceResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockGet struct {
}

func (m *RpcBlockGet) Reset()         { *m = RpcBlockGet{} }
func (m *RpcBlockGet) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGet) ProtoMessage()    {}
func (*RpcBlockGet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 17}
}
func (m *RpcBlockGet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGet.Merge(m, src)
}
func (m *RpcBlockGet) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGet proto.InternalMessageInfo

//
// Get marks list in the selected range in text block.
type RpcBlockGetMarks struct {
}

func (m *RpcBlockGetMarks) Reset()         { *m = RpcBlockGetMarks{} }
func (m *RpcBlockGetMarks) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetMarks) ProtoMessage()    {}
func (*RpcBlockGetMarks) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 17, 0}
}
func (m *RpcBlockGetMarks) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetMarks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetMarks.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetMarks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetMarks.Merge(m, src)
}
func (m *RpcBlockGetMarks) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetMarks) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetMarks.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetMarks proto.InternalMessageInfo

type RpcBlockGetMarksRequest struct {
	ContextId string       `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string       `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Range     *model.Range `protobuf:"bytes,3,opt,name=range,proto3" json:"range,omitempty"`
}

func (m *RpcBlockGetMarksRequest) Reset()         { *m = RpcBlockGetMarksRequest{} }
func (m *RpcBlockGetMarksRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetMarksRequest) ProtoMessage()    {}
func (*RpcBlockGetMarksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 17, 0, 0}
}
func (m *RpcBlockGetMarksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetMarksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetMarksRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetMarksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetMarksRequest.Merge(m, src)
}
func (m *RpcBlockGetMarksRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetMarksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetMarksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetMarksRequest proto.InternalMessageInfo

func (m *RpcBlockGetMarksRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockGetMarksRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockGetMarksRequest) GetRange() *model.Range {
	if m != nil {
		return m.Range
	}
	return nil
}

type RpcBlockGetMarksResponse struct {
	Error *RpcBlockGetMarksResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                 `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockGetMarksResponse) Reset()         { *m = RpcBlockGetMarksResponse{} }
func (m *RpcBlockGetMarksResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetMarksResponse) ProtoMessage()    {}
func (*RpcBlockGetMarksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 17, 0, 1}
}
func (m *RpcBlockGetMarksResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetMarksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetMarksResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetMarksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetMarksResponse.Merge(m, src)
}
func (m *RpcBlockGetMarksResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetMarksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetMarksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetMarksResponse proto.InternalMessageInfo

func (m *RpcBlockGetMarksResponse) GetError() *RpcBlockGetMarksResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockGetMarksResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockGetMarksResponseError struct {
	Code        RpcBlockGetMarksResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockGetMarksResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockGetMarksResponseError) Reset()         { *m = RpcBlockGetMarksResponseError{} }
func (m *RpcBlockGetMarksResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetMarksResponseError) ProtoMessage()    {}
func (*RpcBlockGetMarksResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 17, 0, 1, 0}
}
func (m *RpcBlockGetMarksResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetMarksResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetMarksResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetMarksResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetMarksResponseError.Merge(m, src)
}
func (m *RpcBlockGetMarksResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetMarksResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetMarksResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetMarksResponseError proto.InternalMessageInfo

func (m *RpcBlockGetMarksResponseError) GetCode() RpcBlockGetMarksResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockGetMarksResponseError_NULL
}

func (m *RpcBlockGetMarksResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

// Available undo/redo operations
type RpcBlockUndoRedoCounter struct {
	Undo int32 `protobuf:"varint,1,opt,name=undo,proto3" json:"undo,omitempty"`
	Redo int32 `protobuf:"varint,2,opt,name=redo,proto3" json:"redo,omitempty"`
}

func (m *RpcBlockUndoRedoCounter) Reset()         { *m = RpcBlockUndoRedoCounter{} }
func (m *RpcBlockUndoRedoCounter) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUndoRedoCounter) ProtoMessage()    {}
func (*RpcBlockUndoRedoCounter) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 18}
}
func (m *RpcBlockUndoRedoCounter) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUndoRedoCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUndoRedoCounter.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUndoRedoCounter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUndoRedoCounter.Merge(m, src)
}
func (m *RpcBlockUndoRedoCounter) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUndoRedoCounter) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUndoRedoCounter.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUndoRedoCounter proto.InternalMessageInfo

func (m *RpcBlockUndoRedoCounter) GetUndo() int32 {
	if m != nil {
		return m.Undo
	}
	return 0
}

func (m *RpcBlockUndoRedoCounter) GetRedo() int32 {
	if m != nil {
		return m.Redo
	}
	return 0
}

type RpcBlockUndo struct {
}

func (m *RpcBlockUndo) Reset()         { *m = RpcBlockUndo{} }
func (m *RpcBlockUndo) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUndo) ProtoMessage()    {}
func (*RpcBlockUndo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 19}
}
func (m *RpcBlockUndo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUndo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUndo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUndo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUndo.Merge(m, src)
}
func (m *RpcBlockUndo) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUndo) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUndo.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUndo proto.InternalMessageInfo

type RpcBlockUndoRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

func (m *RpcBlockUndoRequest) Reset()         { *m = RpcBlockUndoRequest{} }
func (m *RpcBlockUndoRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUndoRequest) ProtoMessage()    {}
func (*RpcBlockUndoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 19, 0}
}
func (m *RpcBlockUndoRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUndoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUndoRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUndoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUndoRequest.Merge(m, src)
}
func (m *RpcBlockUndoRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUndoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUndoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUndoRequest proto.InternalMessageInfo

func (m *RpcBlockUndoRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

type RpcBlockUndoResponse struct {
	Error    *RpcBlockUndoResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event    *ResponseEvent             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	Counters *RpcBlockUndoRedoCounter   `protobuf:"bytes,3,opt,name=counters,proto3" json:"counters,omitempty"`
}

func (m *RpcBlockUndoResponse) Reset()         { *m = RpcBlockUndoResponse{} }
func (m *RpcBlockUndoResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUndoResponse) ProtoMessage()    {}
func (*RpcBlockUndoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 19, 1}
}
func (m *RpcBlockUndoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUndoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUndoResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUndoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUndoResponse.Merge(m, src)
}
func (m *RpcBlockUndoResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUndoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUndoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUndoResponse proto.InternalMessageInfo

func (m *RpcBlockUndoResponse) GetError() *RpcBlockUndoResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockUndoResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcBlockUndoResponse) GetCounters() *RpcBlockUndoRedoCounter {
	if m != nil {
		return m.Counters
	}
	return nil
}

type RpcBlockUndoResponseError struct {
	Code        RpcBlockUndoResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockUndoResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockUndoResponseError) Reset()         { *m = RpcBlockUndoResponseError{} }
func (m *RpcBlockUndoResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUndoResponseError) ProtoMessage()    {}
func (*RpcBlockUndoResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 19, 1, 0}
}
func (m *RpcBlockUndoResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUndoResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUndoResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUndoResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUndoResponseError.Merge(m, src)
}
func (m *RpcBlockUndoResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUndoResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUndoResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUndoResponseError proto.InternalMessageInfo

func (m *RpcBlockUndoResponseError) GetCode() RpcBlockUndoResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockUndoResponseError_NULL
}

func (m *RpcBlockUndoResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockRedo struct {
}

func (m *RpcBlockRedo) Reset()         { *m = RpcBlockRedo{} }
func (m *RpcBlockRedo) String() string { return proto.CompactTextString(m) }
func (*RpcBlockRedo) ProtoMessage()    {}
func (*RpcBlockRedo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 20}
}
func (m *RpcBlockRedo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockRedo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockRedo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockRedo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockRedo.Merge(m, src)
}
func (m *RpcBlockRedo) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockRedo) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockRedo.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockRedo proto.InternalMessageInfo

type RpcBlockRedoRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

func (m *RpcBlockRedoRequest) Reset()         { *m = RpcBlockRedoRequest{} }
func (m *RpcBlockRedoRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockRedoRequest) ProtoMessage()    {}
func (*RpcBlockRedoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 20, 0}
}
func (m *RpcBlockRedoRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockRedoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockRedoRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockRedoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockRedoRequest.Merge(m, src)
}
func (m *RpcBlockRedoRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockRedoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockRedoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockRedoRequest proto.InternalMessageInfo

func (m *RpcBlockRedoRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

type RpcBlockRedoResponse struct {
	Error    *RpcBlockRedoResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event    *ResponseEvent             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	Counters *RpcBlockUndoRedoCounter   `protobuf:"bytes,3,opt,name=counters,proto3" json:"counters,omitempty"`
}

func (m *RpcBlockRedoResponse) Reset()         { *m = RpcBlockRedoResponse{} }
func (m *RpcBlockRedoResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockRedoResponse) ProtoMessage()    {}
func (*RpcBlockRedoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 20, 1}
}
func (m *RpcBlockRedoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockRedoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockRedoResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockRedoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockRedoResponse.Merge(m, src)
}
func (m *RpcBlockRedoResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockRedoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockRedoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockRedoResponse proto.InternalMessageInfo

func (m *RpcBlockRedoResponse) GetError() *RpcBlockRedoResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockRedoResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcBlockRedoResponse) GetCounters() *RpcBlockUndoRedoCounter {
	if m != nil {
		return m.Counters
	}
	return nil
}

type RpcBlockRedoResponseError struct {
	Code        RpcBlockRedoResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockRedoResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockRedoResponseError) Reset()         { *m = RpcBlockRedoResponseError{} }
func (m *RpcBlockRedoResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockRedoResponseError) ProtoMessage()    {}
func (*RpcBlockRedoResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 20, 1, 0}
}
func (m *RpcBlockRedoResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockRedoResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockRedoResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockRedoResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockRedoResponseError.Merge(m, src)
}
func (m *RpcBlockRedoResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockRedoResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockRedoResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockRedoResponseError proto.InternalMessageInfo

func (m *RpcBlockRedoResponseError) GetCode() RpcBlockRedoResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockRedoResponseError_NULL
}

func (m *RpcBlockRedoResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Works with a smart blocks (block-organizers, like page, dashboard etc)
// **Example scenario**
// 1A. On front-end start.
//     1. Front -> MW: Rpc.Block.Open.Request(dashboard.id)
//     2. MW -> Front: BlockShow(dashboard)
//     3. MW -> Front: Rpc.Block.Open.Response(err)
// 1B. User clicks on a page icon on the dashboard.
//     1. Front -> MW: Rpc.Block.Close.Request(dashboard.id)
// Get close response first, then open request:
//     2. MW -> Front: Rpc.Block.Close.Response(err)
//     3. Front -> MW: Rpc.Block.Open.Request(page.id)
//     4. MW -> Front: BlockShow(<page, blocks>)
//     5. MW -> Front: Rpc.Block.Open.Response(err)
// Image/Video/File blocks then:
//     6. MW -> Front: BlockShow(<blocks>)
type RpcBlockOpen struct {
}

func (m *RpcBlockOpen) Reset()         { *m = RpcBlockOpen{} }
func (m *RpcBlockOpen) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpen) ProtoMessage()    {}
func (*RpcBlockOpen) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 21}
}
func (m *RpcBlockOpen) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpen.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpen) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpen.Merge(m, src)
}
func (m *RpcBlockOpen) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpen) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpen.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpen proto.InternalMessageInfo

type RpcBlockOpenRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	TraceId   string `protobuf:"bytes,3,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

func (m *RpcBlockOpenRequest) Reset()         { *m = RpcBlockOpenRequest{} }
func (m *RpcBlockOpenRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenRequest) ProtoMessage()    {}
func (*RpcBlockOpenRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 21, 0}
}
func (m *RpcBlockOpenRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenRequest.Merge(m, src)
}
func (m *RpcBlockOpenRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenRequest proto.InternalMessageInfo

func (m *RpcBlockOpenRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockOpenRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockOpenRequest) GetTraceId() string {
	if m != nil {
		return m.TraceId
	}
	return ""
}

type RpcBlockOpenResponse struct {
	Error *RpcBlockOpenResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockOpenResponse) Reset()         { *m = RpcBlockOpenResponse{} }
func (m *RpcBlockOpenResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenResponse) ProtoMessage()    {}
func (*RpcBlockOpenResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 21, 1}
}
func (m *RpcBlockOpenResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenResponse.Merge(m, src)
}
func (m *RpcBlockOpenResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenResponse proto.InternalMessageInfo

func (m *RpcBlockOpenResponse) GetError() *RpcBlockOpenResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockOpenResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	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"`
}

func (m *RpcBlockOpenResponseError) Reset()         { *m = RpcBlockOpenResponseError{} }
func (m *RpcBlockOpenResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenResponseError) ProtoMessage()    {}
func (*RpcBlockOpenResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 21, 1, 0}
}
func (m *RpcBlockOpenResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenResponseError.Merge(m, src)
}
func (m *RpcBlockOpenResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenResponseError proto.InternalMessageInfo

func (m *RpcBlockOpenResponseError) GetCode() RpcBlockOpenResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockOpenResponseError_NULL
}

func (m *RpcBlockOpenResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockShow struct {
}

func (m *RpcBlockShow) Reset()         { *m = RpcBlockShow{} }
func (m *RpcBlockShow) String() string { return proto.CompactTextString(m) }
func (*RpcBlockShow) ProtoMessage()    {}
func (*RpcBlockShow) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 22}
}
func (m *RpcBlockShow) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockShow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockShow.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockShow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockShow.Merge(m, src)
}
func (m *RpcBlockShow) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockShow) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockShow.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockShow proto.InternalMessageInfo

type RpcBlockShowRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	TraceId   string `protobuf:"bytes,3,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

func (m *RpcBlockShowRequest) Reset()         { *m = RpcBlockShowRequest{} }
func (m *RpcBlockShowRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockShowRequest) ProtoMessage()    {}
func (*RpcBlockShowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 22, 0}
}
func (m *RpcBlockShowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockShowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockShowRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockShowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockShowRequest.Merge(m, src)
}
func (m *RpcBlockShowRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockShowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockShowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockShowRequest proto.InternalMessageInfo

func (m *RpcBlockShowRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockShowRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockShowRequest) GetTraceId() string {
	if m != nil {
		return m.TraceId
	}
	return ""
}

type RpcBlockShowResponse struct {
	Error *RpcBlockShowResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockShowResponse) Reset()         { *m = RpcBlockShowResponse{} }
func (m *RpcBlockShowResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockShowResponse) ProtoMessage()    {}
func (*RpcBlockShowResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 22, 1}
}
func (m *RpcBlockShowResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockShowResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockShowResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockShowResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockShowResponse.Merge(m, src)
}
func (m *RpcBlockShowResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockShowResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockShowResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockShowResponse proto.InternalMessageInfo

func (m *RpcBlockShowResponse) GetError() *RpcBlockShowResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockShowResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockShowResponseError struct {
	Code        RpcBlockShowResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockShowResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockShowResponseError) Reset()         { *m = RpcBlockShowResponseError{} }
func (m *RpcBlockShowResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockShowResponseError) ProtoMessage()    {}
func (*RpcBlockShowResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 22, 1, 0}
}
func (m *RpcBlockShowResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockShowResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockShowResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockShowResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockShowResponseError.Merge(m, src)
}
func (m *RpcBlockShowResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockShowResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockShowResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockShowResponseError proto.InternalMessageInfo

func (m *RpcBlockShowResponseError) GetCode() RpcBlockShowResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockShowResponseError_NULL
}

func (m *RpcBlockShowResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockGetPublicWebURL struct {
}

func (m *RpcBlockGetPublicWebURL) Reset()         { *m = RpcBlockGetPublicWebURL{} }
func (m *RpcBlockGetPublicWebURL) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetPublicWebURL) ProtoMessage()    {}
func (*RpcBlockGetPublicWebURL) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 23}
}
func (m *RpcBlockGetPublicWebURL) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetPublicWebURL) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetPublicWebURL.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetPublicWebURL) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetPublicWebURL.Merge(m, src)
}
func (m *RpcBlockGetPublicWebURL) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetPublicWebURL) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetPublicWebURL.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetPublicWebURL proto.InternalMessageInfo

type RpcBlockGetPublicWebURLRequest struct {
	BlockId string `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
}

func (m *RpcBlockGetPublicWebURLRequest) Reset()         { *m = RpcBlockGetPublicWebURLRequest{} }
func (m *RpcBlockGetPublicWebURLRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetPublicWebURLRequest) ProtoMessage()    {}
func (*RpcBlockGetPublicWebURLRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 23, 0}
}
func (m *RpcBlockGetPublicWebURLRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetPublicWebURLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetPublicWebURLRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetPublicWebURLRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetPublicWebURLRequest.Merge(m, src)
}
func (m *RpcBlockGetPublicWebURLRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetPublicWebURLRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetPublicWebURLRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetPublicWebURLRequest proto.InternalMessageInfo

func (m *RpcBlockGetPublicWebURLRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

type RpcBlockGetPublicWebURLResponse struct {
	Error *RpcBlockGetPublicWebURLResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Url   string                                `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
}

func (m *RpcBlockGetPublicWebURLResponse) Reset()         { *m = RpcBlockGetPublicWebURLResponse{} }
func (m *RpcBlockGetPublicWebURLResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetPublicWebURLResponse) ProtoMessage()    {}
func (*RpcBlockGetPublicWebURLResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 23, 1}
}
func (m *RpcBlockGetPublicWebURLResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetPublicWebURLResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetPublicWebURLResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetPublicWebURLResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetPublicWebURLResponse.Merge(m, src)
}
func (m *RpcBlockGetPublicWebURLResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetPublicWebURLResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetPublicWebURLResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetPublicWebURLResponse proto.InternalMessageInfo

func (m *RpcBlockGetPublicWebURLResponse) GetError() *RpcBlockGetPublicWebURLResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockGetPublicWebURLResponse) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type RpcBlockGetPublicWebURLResponseError struct {
	Code        RpcBlockGetPublicWebURLResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockGetPublicWebURLResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockGetPublicWebURLResponseError) Reset()         { *m = RpcBlockGetPublicWebURLResponseError{} }
func (m *RpcBlockGetPublicWebURLResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockGetPublicWebURLResponseError) ProtoMessage()    {}
func (*RpcBlockGetPublicWebURLResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 23, 1, 0}
}
func (m *RpcBlockGetPublicWebURLResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockGetPublicWebURLResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockGetPublicWebURLResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockGetPublicWebURLResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockGetPublicWebURLResponseError.Merge(m, src)
}
func (m *RpcBlockGetPublicWebURLResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockGetPublicWebURLResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockGetPublicWebURLResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockGetPublicWebURLResponseError proto.InternalMessageInfo

func (m *RpcBlockGetPublicWebURLResponseError) GetCode() RpcBlockGetPublicWebURLResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockGetPublicWebURLResponseError_NULL
}

func (m *RpcBlockGetPublicWebURLResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockOpenBreadcrumbs struct {
}

func (m *RpcBlockOpenBreadcrumbs) Reset()         { *m = RpcBlockOpenBreadcrumbs{} }
func (m *RpcBlockOpenBreadcrumbs) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenBreadcrumbs) ProtoMessage()    {}
func (*RpcBlockOpenBreadcrumbs) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 24}
}
func (m *RpcBlockOpenBreadcrumbs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenBreadcrumbs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenBreadcrumbs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenBreadcrumbs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenBreadcrumbs.Merge(m, src)
}
func (m *RpcBlockOpenBreadcrumbs) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenBreadcrumbs) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenBreadcrumbs.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenBreadcrumbs proto.InternalMessageInfo

type RpcBlockOpenBreadcrumbsRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TraceId   string `protobuf:"bytes,2,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

func (m *RpcBlockOpenBreadcrumbsRequest) Reset()         { *m = RpcBlockOpenBreadcrumbsRequest{} }
func (m *RpcBlockOpenBreadcrumbsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenBreadcrumbsRequest) ProtoMessage()    {}
func (*RpcBlockOpenBreadcrumbsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 24, 0}
}
func (m *RpcBlockOpenBreadcrumbsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenBreadcrumbsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenBreadcrumbsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenBreadcrumbsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenBreadcrumbsRequest.Merge(m, src)
}
func (m *RpcBlockOpenBreadcrumbsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenBreadcrumbsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenBreadcrumbsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenBreadcrumbsRequest proto.InternalMessageInfo

func (m *RpcBlockOpenBreadcrumbsRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockOpenBreadcrumbsRequest) GetTraceId() string {
	if m != nil {
		return m.TraceId
	}
	return ""
}

type RpcBlockOpenBreadcrumbsResponse struct {
	Error   *RpcBlockOpenBreadcrumbsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId string                                `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Event   *ResponseEvent                        `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockOpenBreadcrumbsResponse) Reset()         { *m = RpcBlockOpenBreadcrumbsResponse{} }
func (m *RpcBlockOpenBreadcrumbsResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenBreadcrumbsResponse) ProtoMessage()    {}
func (*RpcBlockOpenBreadcrumbsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 24, 1}
}
func (m *RpcBlockOpenBreadcrumbsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenBreadcrumbsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenBreadcrumbsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenBreadcrumbsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenBreadcrumbsResponse.Merge(m, src)
}
func (m *RpcBlockOpenBreadcrumbsResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenBreadcrumbsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenBreadcrumbsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenBreadcrumbsResponse proto.InternalMessageInfo

func (m *RpcBlockOpenBreadcrumbsResponse) GetError() *RpcBlockOpenBreadcrumbsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockOpenBreadcrumbsResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockOpenBreadcrumbsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockOpenBreadcrumbsResponseError struct {
	Code        RpcBlockOpenBreadcrumbsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockOpenBreadcrumbsResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockOpenBreadcrumbsResponseError) Reset()         { *m = RpcBlockOpenBreadcrumbsResponseError{} }
func (m *RpcBlockOpenBreadcrumbsResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockOpenBreadcrumbsResponseError) ProtoMessage()    {}
func (*RpcBlockOpenBreadcrumbsResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 24, 1, 0}
}
func (m *RpcBlockOpenBreadcrumbsResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockOpenBreadcrumbsResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockOpenBreadcrumbsResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockOpenBreadcrumbsResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockOpenBreadcrumbsResponseError.Merge(m, src)
}
func (m *RpcBlockOpenBreadcrumbsResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockOpenBreadcrumbsResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockOpenBreadcrumbsResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockOpenBreadcrumbsResponseError proto.InternalMessageInfo

func (m *RpcBlockOpenBreadcrumbsResponseError) GetCode() RpcBlockOpenBreadcrumbsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockOpenBreadcrumbsResponseError_NULL
}

func (m *RpcBlockOpenBreadcrumbsResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockSetBreadcrumbs struct {
}

func (m *RpcBlockSetBreadcrumbs) Reset()         { *m = RpcBlockSetBreadcrumbs{} }
func (m *RpcBlockSetBreadcrumbs) String() string { return proto.CompactTextString(m) }
func (*RpcBlockSetBreadcrumbs) ProtoMessage()    {}
func (*RpcBlockSetBreadcrumbs) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 25}
}
func (m *RpcBlockSetBreadcrumbs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockSetBreadcrumbs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockSetBreadcrumbs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockSetBreadcrumbs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockSetBreadcrumbs.Merge(m, src)
}
func (m *RpcBlockSetBreadcrumbs) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockSetBreadcrumbs) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockSetBreadcrumbs.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockSetBreadcrumbs proto.InternalMessageInfo

type RpcBlockSetBreadcrumbsRequest struct {
	BreadcrumbsId string   `protobuf:"bytes,1,opt,name=breadcrumbsId,proto3" json:"breadcrumbsId,omitempty"`
	Ids           []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

func (m *RpcBlockSetBreadcrumbsRequest) Reset()         { *m = RpcBlockSetBreadcrumbsRequest{} }
func (m *RpcBlockSetBreadcrumbsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockSetBreadcrumbsRequest) ProtoMessage()    {}
func (*RpcBlockSetBreadcrumbsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 25, 0}
}
func (m *RpcBlockSetBreadcrumbsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockSetBreadcrumbsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockSetBreadcrumbsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockSetBreadcrumbsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockSetBreadcrumbsRequest.Merge(m, src)
}
func (m *RpcBlockSetBreadcrumbsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockSetBreadcrumbsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockSetBreadcrumbsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockSetBreadcrumbsRequest proto.InternalMessageInfo

func (m *RpcBlockSetBreadcrumbsRequest) GetBreadcrumbsId() string {
	if m != nil {
		return m.BreadcrumbsId
	}
	return ""
}

func (m *RpcBlockSetBreadcrumbsRequest) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type RpcBlockSetBreadcrumbsResponse struct {
	Error *RpcBlockSetBreadcrumbsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockSetBreadcrumbsResponse) Reset()         { *m = RpcBlockSetBreadcrumbsResponse{} }
func (m *RpcBlockSetBreadcrumbsResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockSetBreadcrumbsResponse) ProtoMessage()    {}
func (*RpcBlockSetBreadcrumbsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 25, 1}
}
func (m *RpcBlockSetBreadcrumbsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockSetBreadcrumbsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockSetBreadcrumbsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockSetBreadcrumbsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockSetBreadcrumbsResponse.Merge(m, src)
}
func (m *RpcBlockSetBreadcrumbsResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockSetBreadcrumbsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockSetBreadcrumbsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockSetBreadcrumbsResponse proto.InternalMessageInfo

func (m *RpcBlockSetBreadcrumbsResponse) GetError() *RpcBlockSetBreadcrumbsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockSetBreadcrumbsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockSetBreadcrumbsResponseError struct {
	Code        RpcBlockSetBreadcrumbsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockSetBreadcrumbsResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockSetBreadcrumbsResponseError) Reset()         { *m = RpcBlockSetBreadcrumbsResponseError{} }
func (m *RpcBlockSetBreadcrumbsResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockSetBreadcrumbsResponseError) ProtoMessage()    {}
func (*RpcBlockSetBreadcrumbsResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 25, 1, 0}
}
func (m *RpcBlockSetBreadcrumbsResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockSetBreadcrumbsResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockSetBreadcrumbsResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockSetBreadcrumbsResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockSetBreadcrumbsResponseError.Merge(m, src)
}
func (m *RpcBlockSetBreadcrumbsResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockSetBreadcrumbsResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockSetBreadcrumbsResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockSetBreadcrumbsResponseError proto.InternalMessageInfo

func (m *RpcBlockSetBreadcrumbsResponseError) GetCode() RpcBlockSetBreadcrumbsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockSetBreadcrumbsResponseError_NULL
}

func (m *RpcBlockSetBreadcrumbsResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Create a Smart/Internal block. Request can contain a block with a content, or it can be an empty block with a specific block.content.
// **Example scenario**
// 1A. Create Page on a dashboard
//     1. Front -> MW: Rpc.Block.Create.Request(blockId:dashboard.id, position:bottom, block: emtpy block with page content and id = "")
//     2. Front -> MW: Rpc.Block.Close.Request(block: dashboard.id)
//     3. Front <- MW: Rpc.Block.Close.Response(err)
//     4. Front <- MW: Rpc.Block.Create.Response(page.id)
//     5. Front <- MW: Rpc.Block.Open.Response(err)
//     6. Front <- MW: Event.Block.Show(page)
// 1B. Create Page on a Page
//     1. Front -> MW: Rpc.Block.Create.Request(blockId:dashboard.id, position:bottom, block: emtpy block with page content and id = "")
//     2. Front <- MW: Rpc.Block.Create.Response(newPage.id)
//     3. Front <- MW: Event.Block.Show(newPage)
type RpcBlockCreate struct {
}

func (m *RpcBlockCreate) Reset()         { *m = RpcBlockCreate{} }
func (m *RpcBlockCreate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreate) ProtoMessage()    {}
func (*RpcBlockCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 26}
}
func (m *RpcBlockCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreate.Merge(m, src)
}
func (m *RpcBlockCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreate proto.InternalMessageInfo

// common simple block command
type RpcBlockCreateRequest struct {
	ContextId string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TargetId  string              `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Block     *model.Block        `protobuf:"bytes,3,opt,name=block,proto3" json:"block,omitempty"`
	Position  model.BlockPosition `protobuf:"varint,4,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

func (m *RpcBlockCreateRequest) Reset()         { *m = RpcBlockCreateRequest{} }
func (m *RpcBlockCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateRequest) ProtoMessage()    {}
func (*RpcBlockCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 26, 0}
}
func (m *RpcBlockCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateRequest.Merge(m, src)
}
func (m *RpcBlockCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateRequest proto.InternalMessageInfo

func (m *RpcBlockCreateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockCreateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreateRequest) GetBlock() *model.Block {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *RpcBlockCreateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockCreateResponse struct {
	Error   *RpcBlockCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId string                       `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Event   *ResponseEvent               `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockCreateResponse) Reset()         { *m = RpcBlockCreateResponse{} }
func (m *RpcBlockCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateResponse) ProtoMessage()    {}
func (*RpcBlockCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 26, 1}
}
func (m *RpcBlockCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateResponse.Merge(m, src)
}
func (m *RpcBlockCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateResponse proto.InternalMessageInfo

func (m *RpcBlockCreateResponse) GetError() *RpcBlockCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockCreateResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockCreateResponseError struct {
	Code        RpcBlockCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockCreateResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockCreateResponseError) Reset()         { *m = RpcBlockCreateResponseError{} }
func (m *RpcBlockCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateResponseError) ProtoMessage()    {}
func (*RpcBlockCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 26, 1, 0}
}
func (m *RpcBlockCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateResponseError.Merge(m, src)
}
func (m *RpcBlockCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateResponseError proto.InternalMessageInfo

func (m *RpcBlockCreateResponseError) GetCode() RpcBlockCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCreateResponseError_NULL
}

func (m *RpcBlockCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockCreatePage struct {
}

func (m *RpcBlockCreatePage) Reset()         { *m = RpcBlockCreatePage{} }
func (m *RpcBlockCreatePage) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreatePage) ProtoMessage()    {}
func (*RpcBlockCreatePage) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 27}
}
func (m *RpcBlockCreatePage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreatePage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreatePage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreatePage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreatePage.Merge(m, src)
}
func (m *RpcBlockCreatePage) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreatePage) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreatePage.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreatePage proto.InternalMessageInfo

type RpcBlockCreatePageRequest struct {
	ContextId  string        `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Details    *types.Struct `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
	TemplateId string        `protobuf:"bytes,5,opt,name=templateId,proto3" json:"templateId,omitempty"`
	// link block params
	TargetId string              `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position model.BlockPosition `protobuf:"varint,4,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
	Fields   *types.Struct       `protobuf:"bytes,6,opt,name=fields,proto3" json:"fields,omitempty"`
}

func (m *RpcBlockCreatePageRequest) Reset()         { *m = RpcBlockCreatePageRequest{} }
func (m *RpcBlockCreatePageRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreatePageRequest) ProtoMessage()    {}
func (*RpcBlockCreatePageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 27, 0}
}
func (m *RpcBlockCreatePageRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreatePageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreatePageRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreatePageRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreatePageRequest.Merge(m, src)
}
func (m *RpcBlockCreatePageRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreatePageRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreatePageRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreatePageRequest proto.InternalMessageInfo

func (m *RpcBlockCreatePageRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockCreatePageRequest) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *RpcBlockCreatePageRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

func (m *RpcBlockCreatePageRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreatePageRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *RpcBlockCreatePageRequest) GetFields() *types.Struct {
	if m != nil {
		return m.Fields
	}
	return nil
}

type RpcBlockCreatePageResponse struct {
	Error    *RpcBlockCreatePageResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId  string                           `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	TargetId string                           `protobuf:"bytes,3,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Event    *ResponseEvent                   `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockCreatePageResponse) Reset()         { *m = RpcBlockCreatePageResponse{} }
func (m *RpcBlockCreatePageResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreatePageResponse) ProtoMessage()    {}
func (*RpcBlockCreatePageResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 27, 1}
}
func (m *RpcBlockCreatePageResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreatePageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreatePageResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreatePageResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreatePageResponse.Merge(m, src)
}
func (m *RpcBlockCreatePageResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreatePageResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreatePageResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreatePageResponse proto.InternalMessageInfo

func (m *RpcBlockCreatePageResponse) GetError() *RpcBlockCreatePageResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockCreatePageResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockCreatePageResponse) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreatePageResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockCreatePageResponseError struct {
	Code        RpcBlockCreatePageResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockCreatePageResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockCreatePageResponseError) Reset()         { *m = RpcBlockCreatePageResponseError{} }
func (m *RpcBlockCreatePageResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreatePageResponseError) ProtoMessage()    {}
func (*RpcBlockCreatePageResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 27, 1, 0}
}
func (m *RpcBlockCreatePageResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreatePageResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreatePageResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreatePageResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreatePageResponseError.Merge(m, src)
}
func (m *RpcBlockCreatePageResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreatePageResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreatePageResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreatePageResponseError proto.InternalMessageInfo

func (m *RpcBlockCreatePageResponseError) GetCode() RpcBlockCreatePageResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCreatePageResponseError_NULL
}

func (m *RpcBlockCreatePageResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockCreateSet struct {
}

func (m *RpcBlockCreateSet) Reset()         { *m = RpcBlockCreateSet{} }
func (m *RpcBlockCreateSet) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateSet) ProtoMessage()    {}
func (*RpcBlockCreateSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 28}
}
func (m *RpcBlockCreateSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateSet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateSet.Merge(m, src)
}
func (m *RpcBlockCreateSet) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateSet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateSet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateSet proto.InternalMessageInfo

type RpcBlockCreateSetRequest struct {
	ContextId string              `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	TargetId  string              `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Source    []string            `protobuf:"bytes,3,rep,name=source,proto3" json:"source,omitempty"`
	Details   *types.Struct       `protobuf:"bytes,4,opt,name=details,proto3" json:"details,omitempty"`
	Position  model.BlockPosition `protobuf:"varint,5,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

func (m *RpcBlockCreateSetRequest) Reset()         { *m = RpcBlockCreateSetRequest{} }
func (m *RpcBlockCreateSetRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateSetRequest) ProtoMessage()    {}
func (*RpcBlockCreateSetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 28, 0}
}
func (m *RpcBlockCreateSetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateSetRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateSetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateSetRequest.Merge(m, src)
}
func (m *RpcBlockCreateSetRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateSetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateSetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateSetRequest proto.InternalMessageInfo

func (m *RpcBlockCreateSetRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockCreateSetRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreateSetRequest) GetSource() []string {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *RpcBlockCreateSetRequest) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *RpcBlockCreateSetRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockCreateSetResponse struct {
	Error    *RpcBlockCreateSetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BlockId  string                          `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
	TargetId string                          `protobuf:"bytes,3,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Event    *ResponseEvent                  `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockCreateSetResponse) Reset()         { *m = RpcBlockCreateSetResponse{} }
func (m *RpcBlockCreateSetResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateSetResponse) ProtoMessage()    {}
func (*RpcBlockCreateSetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 28, 1}
}
func (m *RpcBlockCreateSetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateSetResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateSetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateSetResponse.Merge(m, src)
}
func (m *RpcBlockCreateSetResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateSetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateSetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateSetResponse proto.InternalMessageInfo

func (m *RpcBlockCreateSetResponse) GetError() *RpcBlockCreateSetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockCreateSetResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockCreateSetResponse) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreateSetResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockCreateSetResponseError struct {
	Code        RpcBlockCreateSetResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockCreateSetResponseErrorCode" json:"code,omitempty"`
	Description string                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockCreateSetResponseError) Reset()         { *m = RpcBlockCreateSetResponseError{} }
func (m *RpcBlockCreateSetResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateSetResponseError) ProtoMessage()    {}
func (*RpcBlockCreateSetResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 28, 1, 0}
}
func (m *RpcBlockCreateSetResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateSetResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateSetResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateSetResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateSetResponseError.Merge(m, src)
}
func (m *RpcBlockCreateSetResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateSetResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateSetResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateSetResponseError proto.InternalMessageInfo

func (m *RpcBlockCreateSetResponseError) GetCode() RpcBlockCreateSetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCreateSetResponseError_NULL
}

func (m *RpcBlockCreateSetResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Remove blocks from the childrenIds of its parents
type RpcBlockUnlink struct {
}

func (m *RpcBlockUnlink) Reset()         { *m = RpcBlockUnlink{} }
func (m *RpcBlockUnlink) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUnlink) ProtoMessage()    {}
func (*RpcBlockUnlink) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 29}
}
func (m *RpcBlockUnlink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUnlink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUnlink.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUnlink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUnlink.Merge(m, src)
}
func (m *RpcBlockUnlink) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUnlink) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUnlink.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUnlink proto.InternalMessageInfo

type RpcBlockUnlinkRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockIds  []string `protobuf:"bytes,2,rep,name=blockIds,proto3" json:"blockIds,omitempty"`
}

func (m *RpcBlockUnlinkRequest) Reset()         { *m = RpcBlockUnlinkRequest{} }
func (m *RpcBlockUnlinkRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUnlinkRequest) ProtoMessage()    {}
func (*RpcBlockUnlinkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 29, 0}
}
func (m *RpcBlockUnlinkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUnlinkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUnlinkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUnlinkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUnlinkRequest.Merge(m, src)
}
func (m *RpcBlockUnlinkRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUnlinkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUnlinkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUnlinkRequest proto.InternalMessageInfo

func (m *RpcBlockUnlinkRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockUnlinkRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type RpcBlockUnlinkResponse struct {
	Error *RpcBlockUnlinkResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent               `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockUnlinkResponse) Reset()         { *m = RpcBlockUnlinkResponse{} }
func (m *RpcBlockUnlinkResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUnlinkResponse) ProtoMessage()    {}
func (*RpcBlockUnlinkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 29, 1}
}
func (m *RpcBlockUnlinkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUnlinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUnlinkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUnlinkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUnlinkResponse.Merge(m, src)
}
func (m *RpcBlockUnlinkResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUnlinkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUnlinkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUnlinkResponse proto.InternalMessageInfo

func (m *RpcBlockUnlinkResponse) GetError() *RpcBlockUnlinkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockUnlinkResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockUnlinkResponseError struct {
	Code        RpcBlockUnlinkResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockUnlinkResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockUnlinkResponseError) Reset()         { *m = RpcBlockUnlinkResponseError{} }
func (m *RpcBlockUnlinkResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockUnlinkResponseError) ProtoMessage()    {}
func (*RpcBlockUnlinkResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 29, 1, 0}
}
func (m *RpcBlockUnlinkResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockUnlinkResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockUnlinkResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockUnlinkResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockUnlinkResponseError.Merge(m, src)
}
func (m *RpcBlockUnlinkResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockUnlinkResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockUnlinkResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockUnlinkResponseError proto.InternalMessageInfo

func (m *RpcBlockUnlinkResponseError) GetCode() RpcBlockUnlinkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockUnlinkResponseError_NULL
}

func (m *RpcBlockUnlinkResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Block.Close – it means unsubscribe from a block.
// Precondition: block should be opened.
type RpcBlockClose struct {
}

func (m *RpcBlockClose) Reset()         { *m = RpcBlockClose{} }
func (m *RpcBlockClose) String() string { return proto.CompactTextString(m) }
func (*RpcBlockClose) ProtoMessage()    {}
func (*RpcBlockClose) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 30}
}
func (m *RpcBlockClose) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockClose.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockClose) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockClose.Merge(m, src)
}
func (m *RpcBlockClose) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockClose) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockClose.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockClose proto.InternalMessageInfo

type RpcBlockCloseRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	BlockId   string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
}

func (m *RpcBlockCloseRequest) Reset()         { *m = RpcBlockCloseRequest{} }
func (m *RpcBlockCloseRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCloseRequest) ProtoMessage()    {}
func (*RpcBlockCloseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 30, 0}
}
func (m *RpcBlockCloseRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCloseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCloseRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCloseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCloseRequest.Merge(m, src)
}
func (m *RpcBlockCloseRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCloseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCloseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCloseRequest proto.InternalMessageInfo

func (m *RpcBlockCloseRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockCloseRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

type RpcBlockCloseResponse struct {
	Error *RpcBlockCloseResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcBlockCloseResponse) Reset()         { *m = RpcBlockCloseResponse{} }
func (m *RpcBlockCloseResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCloseResponse) ProtoMessage()    {}
func (*RpcBlockCloseResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 30, 1}
}
func (m *RpcBlockCloseResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCloseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCloseResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCloseResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCloseResponse.Merge(m, src)
}
func (m *RpcBlockCloseResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCloseResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCloseResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCloseResponse proto.InternalMessageInfo

func (m *RpcBlockCloseResponse) GetError() *RpcBlockCloseResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockCloseResponseError struct {
	Code        RpcBlockCloseResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockCloseResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockCloseResponseError) Reset()         { *m = RpcBlockCloseResponseError{} }
func (m *RpcBlockCloseResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCloseResponseError) ProtoMessage()    {}
func (*RpcBlockCloseResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 30, 1, 0}
}
func (m *RpcBlockCloseResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCloseResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCloseResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCloseResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCloseResponseError.Merge(m, src)
}
func (m *RpcBlockCloseResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCloseResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCloseResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCloseResponseError proto.InternalMessageInfo

func (m *RpcBlockCloseResponseError) GetCode() RpcBlockCloseResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCloseResponseError_NULL
}

func (m *RpcBlockCloseResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWorkspace struct {
}

func (m *RpcWorkspace) Reset()         { *m = RpcWorkspace{} }
func (m *RpcWorkspace) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspace) ProtoMessage()    {}
func (*RpcWorkspace) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4}
}
func (m *RpcWorkspace) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspace.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspace.Merge(m, src)
}
func (m *RpcWorkspace) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspace) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspace.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspace proto.InternalMessageInfo

type RpcWorkspaceGetCurrent struct {
}

func (m *RpcWorkspaceGetCurrent) Reset()         { *m = RpcWorkspaceGetCurrent{} }
func (m *RpcWorkspaceGetCurrent) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetCurrent) ProtoMessage()    {}
func (*RpcWorkspaceGetCurrent) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 0}
}
func (m *RpcWorkspaceGetCurrent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetCurrent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetCurrent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetCurrent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetCurrent.Merge(m, src)
}
func (m *RpcWorkspaceGetCurrent) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetCurrent) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetCurrent.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetCurrent proto.InternalMessageInfo

type RpcWorkspaceGetCurrentRequest struct {
}

func (m *RpcWorkspaceGetCurrentRequest) Reset()         { *m = RpcWorkspaceGetCurrentRequest{} }
func (m *RpcWorkspaceGetCurrentRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetCurrentRequest) ProtoMessage()    {}
func (*RpcWorkspaceGetCurrentRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 0, 0}
}
func (m *RpcWorkspaceGetCurrentRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetCurrentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetCurrentRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetCurrentRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetCurrentRequest.Merge(m, src)
}
func (m *RpcWorkspaceGetCurrentRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetCurrentRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetCurrentRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetCurrentRequest proto.InternalMessageInfo

type RpcWorkspaceGetCurrentResponse struct {
	Error       *RpcWorkspaceGetCurrentResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	WorkspaceId string                               `protobuf:"bytes,2,opt,name=workspaceId,proto3" json:"workspaceId,omitempty"`
}

func (m *RpcWorkspaceGetCurrentResponse) Reset()         { *m = RpcWorkspaceGetCurrentResponse{} }
func (m *RpcWorkspaceGetCurrentResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetCurrentResponse) ProtoMessage()    {}
func (*RpcWorkspaceGetCurrentResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 0, 1}
}
func (m *RpcWorkspaceGetCurrentResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetCurrentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetCurrentResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetCurrentResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetCurrentResponse.Merge(m, src)
}
func (m *RpcWorkspaceGetCurrentResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetCurrentResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetCurrentResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetCurrentResponse proto.InternalMessageInfo

func (m *RpcWorkspaceGetCurrentResponse) GetError() *RpcWorkspaceGetCurrentResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWorkspaceGetCurrentResponse) GetWorkspaceId() string {
	if m != nil {
		return m.WorkspaceId
	}
	return ""
}

type RpcWorkspaceGetCurrentResponseError struct {
	Code        RpcWorkspaceGetCurrentResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWorkspaceGetCurrentResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWorkspaceGetCurrentResponseError) Reset()         { *m = RpcWorkspaceGetCurrentResponseError{} }
func (m *RpcWorkspaceGetCurrentResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetCurrentResponseError) ProtoMessage()    {}
func (*RpcWorkspaceGetCurrentResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 0, 1, 0}
}
func (m *RpcWorkspaceGetCurrentResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetCurrentResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetCurrentResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetCurrentResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetCurrentResponseError.Merge(m, src)
}
func (m *RpcWorkspaceGetCurrentResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetCurrentResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetCurrentResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetCurrentResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceGetCurrentResponseError) GetCode() RpcWorkspaceGetCurrentResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceGetCurrentResponseError_NULL
}

func (m *RpcWorkspaceGetCurrentResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWorkspaceGetAll struct {
}

func (m *RpcWorkspaceGetAll) Reset()         { *m = RpcWorkspaceGetAll{} }
func (m *RpcWorkspaceGetAll) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetAll) ProtoMessage()    {}
func (*RpcWorkspaceGetAll) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 1}
}
func (m *RpcWorkspaceGetAll) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetAll) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetAll.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetAll) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetAll.Merge(m, src)
}
func (m *RpcWorkspaceGetAll) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetAll) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetAll.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetAll proto.InternalMessageInfo

type RpcWorkspaceGetAllRequest struct {
}

func (m *RpcWorkspaceGetAllRequest) Reset()         { *m = RpcWorkspaceGetAllRequest{} }
func (m *RpcWorkspaceGetAllRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetAllRequest) ProtoMessage()    {}
func (*RpcWorkspaceGetAllRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 1, 0}
}
func (m *RpcWorkspaceGetAllRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetAllRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetAllRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetAllRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetAllRequest.Merge(m, src)
}
func (m *RpcWorkspaceGetAllRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetAllRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetAllRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetAllRequest proto.InternalMessageInfo

type RpcWorkspaceGetAllResponse struct {
	Error        *RpcWorkspaceGetAllResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	WorkspaceIds []string                         `protobuf:"bytes,2,rep,name=workspaceIds,proto3" json:"workspaceIds,omitempty"`
}

func (m *RpcWorkspaceGetAllResponse) Reset()         { *m = RpcWorkspaceGetAllResponse{} }
func (m *RpcWorkspaceGetAllResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetAllResponse) ProtoMessage()    {}
func (*RpcWorkspaceGetAllResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 1, 1}
}
func (m *RpcWorkspaceGetAllResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetAllResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetAllResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetAllResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetAllResponse.Merge(m, src)
}
func (m *RpcWorkspaceGetAllResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetAllResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetAllResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetAllResponse proto.InternalMessageInfo

func (m *RpcWorkspaceGetAllResponse) GetError() *RpcWorkspaceGetAllResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWorkspaceGetAllResponse) GetWorkspaceIds() []string {
	if m != nil {
		return m.WorkspaceIds
	}
	return nil
}

type RpcWorkspaceGetAllResponseError struct {
	Code        RpcWorkspaceGetAllResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWorkspaceGetAllResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWorkspaceGetAllResponseError) Reset()         { *m = RpcWorkspaceGetAllResponseError{} }
func (m *RpcWorkspaceGetAllResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceGetAllResponseError) ProtoMessage()    {}
func (*RpcWorkspaceGetAllResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 1, 1, 0}
}
func (m *RpcWorkspaceGetAllResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceGetAllResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceGetAllResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceGetAllResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceGetAllResponseError.Merge(m, src)
}
func (m *RpcWorkspaceGetAllResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceGetAllResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceGetAllResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceGetAllResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceGetAllResponseError) GetCode() RpcWorkspaceGetAllResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceGetAllResponseError_NULL
}

func (m *RpcWorkspaceGetAllResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWorkspaceCreate struct {
}

func (m *RpcWorkspaceCreate) Reset()         { *m = RpcWorkspaceCreate{} }
func (m *RpcWorkspaceCreate) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceCreate) ProtoMessage()    {}
func (*RpcWorkspaceCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 2}
}
func (m *RpcWorkspaceCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceCreate.Merge(m, src)
}
func (m *RpcWorkspaceCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceCreate proto.InternalMessageInfo

type RpcWorkspaceCreateRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *RpcWorkspaceCreateRequest) Reset()         { *m = RpcWorkspaceCreateRequest{} }
func (m *RpcWorkspaceCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceCreateRequest) ProtoMessage()    {}
func (*RpcWorkspaceCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 2, 0}
}
func (m *RpcWorkspaceCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceCreateRequest.Merge(m, src)
}
func (m *RpcWorkspaceCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceCreateRequest proto.InternalMessageInfo

func (m *RpcWorkspaceCreateRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type RpcWorkspaceCreateResponse struct {
	Error       *RpcWorkspaceCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	WorkspaceId string                           `protobuf:"bytes,2,opt,name=workspaceId,proto3" json:"workspaceId,omitempty"`
}

func (m *RpcWorkspaceCreateResponse) Reset()         { *m = RpcWorkspaceCreateResponse{} }
func (m *RpcWorkspaceCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceCreateResponse) ProtoMessage()    {}
func (*RpcWorkspaceCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 2, 1}
}
func (m *RpcWorkspaceCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceCreateResponse.Merge(m, src)
}
func (m *RpcWorkspaceCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceCreateResponse proto.InternalMessageInfo

func (m *RpcWorkspaceCreateResponse) GetError() *RpcWorkspaceCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWorkspaceCreateResponse) GetWorkspaceId() string {
	if m != nil {
		return m.WorkspaceId
	}
	return ""
}

type RpcWorkspaceCreateResponseError struct {
	Code        RpcWorkspaceCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWorkspaceCreateResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWorkspaceCreateResponseError) Reset()         { *m = RpcWorkspaceCreateResponseError{} }
func (m *RpcWorkspaceCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceCreateResponseError) ProtoMessage()    {}
func (*RpcWorkspaceCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 2, 1, 0}
}
func (m *RpcWorkspaceCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceCreateResponseError.Merge(m, src)
}
func (m *RpcWorkspaceCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceCreateResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceCreateResponseError) GetCode() RpcWorkspaceCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceCreateResponseError_NULL
}

func (m *RpcWorkspaceCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWorkspaceSetIsHighlighted struct {
}

func (m *RpcWorkspaceSetIsHighlighted) Reset()         { *m = RpcWorkspaceSetIsHighlighted{} }
func (m *RpcWorkspaceSetIsHighlighted) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSetIsHighlighted) ProtoMessage()    {}
func (*RpcWorkspaceSetIsHighlighted) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 3}
}
func (m *RpcWorkspaceSetIsHighlighted) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSetIsHighlighted) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSetIsHighlighted.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSetIsHighlighted) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSetIsHighlighted.Merge(m, src)
}
func (m *RpcWorkspaceSetIsHighlighted) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSetIsHighlighted) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSetIsHighlighted.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSetIsHighlighted proto.InternalMessageInfo

type RpcWorkspaceSetIsHighlightedRequest struct {
	ObjectId      string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
	IsHighlighted bool   `protobuf:"varint,2,opt,name=isHighlighted,proto3" json:"isHighlighted,omitempty"`
}

func (m *RpcWorkspaceSetIsHighlightedRequest) Reset()         { *m = RpcWorkspaceSetIsHighlightedRequest{} }
func (m *RpcWorkspaceSetIsHighlightedRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSetIsHighlightedRequest) ProtoMessage()    {}
func (*RpcWorkspaceSetIsHighlightedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 3, 0}
}
func (m *RpcWorkspaceSetIsHighlightedRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSetIsHighlightedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSetIsHighlightedRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSetIsHighlightedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSetIsHighlightedRequest.Merge(m, src)
}
func (m *RpcWorkspaceSetIsHighlightedRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSetIsHighlightedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSetIsHighlightedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSetIsHighlightedRequest proto.InternalMessageInfo

func (m *RpcWorkspaceSetIsHighlightedRequest) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	return ""
}

func (m *RpcWorkspaceSetIsHighlightedRequest) GetIsHighlighted() bool {
	if m != nil {
		return m.IsHighlighted
	}
	return false
}

type RpcWorkspaceSetIsHighlightedResponse struct {
	Error *RpcWorkspaceSetIsHighlightedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcWorkspaceSetIsHighlightedResponse) Reset()         { *m = RpcWorkspaceSetIsHighlightedResponse{} }
func (m *RpcWorkspaceSetIsHighlightedResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSetIsHighlightedResponse) ProtoMessage()    {}
func (*RpcWorkspaceSetIsHighlightedResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 3, 1}
}
func (m *RpcWorkspaceSetIsHighlightedResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSetIsHighlightedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSetIsHighlightedResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponse.Merge(m, src)
}
func (m *RpcWorkspaceSetIsHighlightedResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSetIsHighlightedResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponse proto.InternalMessageInfo

func (m *RpcWorkspaceSetIsHighlightedResponse) GetError() *RpcWorkspaceSetIsHighlightedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcWorkspaceSetIsHighlightedResponseError struct {
	Code        RpcWorkspaceSetIsHighlightedResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWorkspaceSetIsHighlightedResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWorkspaceSetIsHighlightedResponseError) Reset() {
	*m = RpcWorkspaceSetIsHighlightedResponseError{}
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcWorkspaceSetIsHighlightedResponseError) ProtoMessage() {}
func (*RpcWorkspaceSetIsHighlightedResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 3, 1, 0}
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponseError.Merge(m, src)
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSetIsHighlightedResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceSetIsHighlightedResponseError) GetCode() RpcWorkspaceSetIsHighlightedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceSetIsHighlightedResponseError_NULL
}

func (m *RpcWorkspaceSetIsHighlightedResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWorkspaceSelect struct {
}

func (m *RpcWorkspaceSelect) Reset()         { *m = RpcWorkspaceSelect{} }
func (m *RpcWorkspaceSelect) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSelect) ProtoMessage()    {}
func (*RpcWorkspaceSelect) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 4}
}
func (m *RpcWorkspaceSelect) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSelect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSelect.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSelect) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSelect.Merge(m, src)
}
func (m *RpcWorkspaceSelect) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSelect) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSelect.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSelect proto.InternalMessageInfo

type RpcWorkspaceSelectRequest struct {
	WorkspaceId string `protobuf:"bytes,1,opt,name=workspaceId,proto3" json:"workspaceId,omitempty"`
}

func (m *RpcWorkspaceSelectRequest) Reset()         { *m = RpcWorkspaceSelectRequest{} }
func (m *RpcWorkspaceSelectRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSelectRequest) ProtoMessage()    {}
func (*RpcWorkspaceSelectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 4, 0}
}
func (m *RpcWorkspaceSelectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSelectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSelectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSelectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSelectRequest.Merge(m, src)
}
func (m *RpcWorkspaceSelectRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSelectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSelectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSelectRequest proto.InternalMessageInfo

func (m *RpcWorkspaceSelectRequest) GetWorkspaceId() string {
	if m != nil {
		return m.WorkspaceId
	}
	return ""
}

type RpcWorkspaceSelectResponse struct {
	Error *RpcWorkspaceSelectResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcWorkspaceSelectResponse) Reset()         { *m = RpcWorkspaceSelectResponse{} }
func (m *RpcWorkspaceSelectResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSelectResponse) ProtoMessage()    {}
func (*RpcWorkspaceSelectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 4, 1}
}
func (m *RpcWorkspaceSelectResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSelectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSelectResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSelectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSelectResponse.Merge(m, src)
}
func (m *RpcWorkspaceSelectResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSelectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSelectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSelectResponse proto.InternalMessageInfo

func (m *RpcWorkspaceSelectResponse) GetError() *RpcWorkspaceSelectResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcWorkspaceSelectResponseError struct {
	Code        RpcWorkspaceSelectResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWorkspaceSelectResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWorkspaceSelectResponseError) Reset()         { *m = RpcWorkspaceSelectResponseError{} }
func (m *RpcWorkspaceSelectResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceSelectResponseError) ProtoMessage()    {}
func (*RpcWorkspaceSelectResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 4, 1, 0}
}
func (m *RpcWorkspaceSelectResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceSelectResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceSelectResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceSelectResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceSelectResponseError.Merge(m, src)
}
func (m *RpcWorkspaceSelectResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceSelectResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceSelectResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceSelectResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceSelectResponseError) GetCode() RpcWorkspaceSelectResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceSelectResponseError_NULL
}

func (m *RpcWorkspaceSelectResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Namespace, that aggregates subtopics and actions, that relates to wallet.
type RpcWallet struct {
}

func (m *RpcWallet) Reset()         { *m = RpcWallet{} }
func (m *RpcWallet) String() string { return proto.CompactTextString(m) }
func (*RpcWallet) ProtoMessage()    {}
func (*RpcWallet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5}
}
func (m *RpcWallet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWallet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWallet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWallet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWallet.Merge(m, src)
}
func (m *RpcWallet) XXX_Size() int {
	return m.Size()
}
func (m *RpcWallet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWallet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWallet proto.InternalMessageInfo

type RpcWalletCreate struct {
}

func (m *RpcWalletCreate) Reset()         { *m = RpcWalletCreate{} }
func (m *RpcWalletCreate) String() string { return proto.CompactTextString(m) }
func (*RpcWalletCreate) ProtoMessage()    {}
func (*RpcWalletCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 0}
}
func (m *RpcWalletCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletCreate.Merge(m, src)
}
func (m *RpcWalletCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletCreate proto.InternalMessageInfo

//*
// Front-end-to-middleware request to create a new wallet
type RpcWalletCreateRequest struct {
	RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"`
}

func (m *RpcWalletCreateRequest) Reset()         { *m = RpcWalletCreateRequest{} }
func (m *RpcWalletCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWalletCreateRequest) ProtoMessage()    {}
func (*RpcWalletCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 0, 0}
}
func (m *RpcWalletCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletCreateRequest.Merge(m, src)
}
func (m *RpcWalletCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletCreateRequest proto.InternalMessageInfo

func (m *RpcWalletCreateRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

//*
// Middleware-to-front-end response, that can contain mnemonic of a created account and a NULL error or an empty mnemonic and a non-NULL error
type RpcWalletCreateResponse struct {
	Error    *RpcWalletCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Mnemonic string                        `protobuf:"bytes,2,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"`
}

func (m *RpcWalletCreateResponse) Reset()         { *m = RpcWalletCreateResponse{} }
func (m *RpcWalletCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWalletCreateResponse) ProtoMessage()    {}
func (*RpcWalletCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 0, 1}
}
func (m *RpcWalletCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletCreateResponse.Merge(m, src)
}
func (m *RpcWalletCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletCreateResponse proto.InternalMessageInfo

func (m *RpcWalletCreateResponse) GetError() *RpcWalletCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWalletCreateResponse) GetMnemonic() string {
	if m != nil {
		return m.Mnemonic
	}
	return ""
}

type RpcWalletCreateResponseError struct {
	Code        RpcWalletCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWalletCreateResponseErrorCode" json:"code,omitempty"`
	Description string                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWalletCreateResponseError) Reset()         { *m = RpcWalletCreateResponseError{} }
func (m *RpcWalletCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWalletCreateResponseError) ProtoMessage()    {}
func (*RpcWalletCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 0, 1, 0}
}
func (m *RpcWalletCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletCreateResponseError.Merge(m, src)
}
func (m *RpcWalletCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletCreateResponseError proto.InternalMessageInfo

func (m *RpcWalletCreateResponseError) GetCode() RpcWalletCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWalletCreateResponseError_NULL
}

func (m *RpcWalletCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWalletRecover struct {
}

func (m *RpcWalletRecover) Reset()         { *m = RpcWalletRecover{} }
func (m *RpcWalletRecover) String() string { return proto.CompactTextString(m) }
func (*RpcWalletRecover) ProtoMessage()    {}
func (*RpcWalletRecover) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 1}
}
func (m *RpcWalletRecover) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletRecover) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletRecover.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletRecover) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletRecover.Merge(m, src)
}
func (m *RpcWalletRecover) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletRecover) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletRecover.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletRecover proto.InternalMessageInfo

//*
// Front end to middleware request-to-recover-a wallet with this mnemonic and a rootPath
type RpcWalletRecoverRequest struct {
	RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"`
	Mnemonic string `protobuf:"bytes,2,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"`
}

func (m *RpcWalletRecoverRequest) Reset()         { *m = RpcWalletRecoverRequest{} }
func (m *RpcWalletRecoverRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWalletRecoverRequest) ProtoMessage()    {}
func (*RpcWalletRecoverRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 1, 0}
}
func (m *RpcWalletRecoverRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletRecoverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletRecoverRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletRecoverRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletRecoverRequest.Merge(m, src)
}
func (m *RpcWalletRecoverRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletRecoverRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletRecoverRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletRecoverRequest proto.InternalMessageInfo

func (m *RpcWalletRecoverRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

func (m *RpcWalletRecoverRequest) GetMnemonic() string {
	if m != nil {
		return m.Mnemonic
	}
	return ""
}

//*
// Middleware-to-front-end response, that can contain a NULL error or a non-NULL error
type RpcWalletRecoverResponse struct {
	Error *RpcWalletRecoverResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcWalletRecoverResponse) Reset()         { *m = RpcWalletRecoverResponse{} }
func (m *RpcWalletRecoverResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWalletRecoverResponse) ProtoMessage()    {}
func (*RpcWalletRecoverResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 1, 1}
}
func (m *RpcWalletRecoverResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletRecoverResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletRecoverResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletRecoverResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletRecoverResponse.Merge(m, src)
}
func (m *RpcWalletRecoverResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletRecoverResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletRecoverResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletRecoverResponse proto.InternalMessageInfo

func (m *RpcWalletRecoverResponse) GetError() *RpcWalletRecoverResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcWalletRecoverResponseError struct {
	Code        RpcWalletRecoverResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWalletRecoverResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWalletRecoverResponseError) Reset()         { *m = RpcWalletRecoverResponseError{} }
func (m *RpcWalletRecoverResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWalletRecoverResponseError) ProtoMessage()    {}
func (*RpcWalletRecoverResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 1, 1, 0}
}
func (m *RpcWalletRecoverResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletRecoverResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletRecoverResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletRecoverResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletRecoverResponseError.Merge(m, src)
}
func (m *RpcWalletRecoverResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletRecoverResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletRecoverResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletRecoverResponseError proto.InternalMessageInfo

func (m *RpcWalletRecoverResponseError) GetCode() RpcWalletRecoverResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWalletRecoverResponseError_NULL
}

func (m *RpcWalletRecoverResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcWalletConvert struct {
}

func (m *RpcWalletConvert) Reset()         { *m = RpcWalletConvert{} }
func (m *RpcWalletConvert) String() string { return proto.CompactTextString(m) }
func (*RpcWalletConvert) ProtoMessage()    {}
func (*RpcWalletConvert) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 2}
}
func (m *RpcWalletConvert) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletConvert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletConvert.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletConvert) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletConvert.Merge(m, src)
}
func (m *RpcWalletConvert) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletConvert) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletConvert.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletConvert proto.InternalMessageInfo

type RpcWalletConvertRequest struct {
	Mnemonic string `protobuf:"bytes,1,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"`
	Entropy  string `protobuf:"bytes,2,opt,name=entropy,proto3" json:"entropy,omitempty"`
}

func (m *RpcWalletConvertRequest) Reset()         { *m = RpcWalletConvertRequest{} }
func (m *RpcWalletConvertRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWalletConvertRequest) ProtoMessage()    {}
func (*RpcWalletConvertRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 2, 0}
}
func (m *RpcWalletConvertRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletConvertRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletConvertRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletConvertRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletConvertRequest.Merge(m, src)
}
func (m *RpcWalletConvertRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletConvertRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletConvertRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletConvertRequest proto.InternalMessageInfo

func (m *RpcWalletConvertRequest) GetMnemonic() string {
	if m != nil {
		return m.Mnemonic
	}
	return ""
}

func (m *RpcWalletConvertRequest) GetEntropy() string {
	if m != nil {
		return m.Entropy
	}
	return ""
}

type RpcWalletConvertResponse struct {
	Error    *RpcWalletConvertResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Entropy  string                         `protobuf:"bytes,2,opt,name=entropy,proto3" json:"entropy,omitempty"`
	Mnemonic string                         `protobuf:"bytes,3,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"`
}

func (m *RpcWalletConvertResponse) Reset()         { *m = RpcWalletConvertResponse{} }
func (m *RpcWalletConvertResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWalletConvertResponse) ProtoMessage()    {}
func (*RpcWalletConvertResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 2, 1}
}
func (m *RpcWalletConvertResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletConvertResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletConvertResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletConvertResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletConvertResponse.Merge(m, src)
}
func (m *RpcWalletConvertResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletConvertResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletConvertResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletConvertResponse proto.InternalMessageInfo

func (m *RpcWalletConvertResponse) GetError() *RpcWalletConvertResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWalletConvertResponse) GetEntropy() string {
	if m != nil {
		return m.Entropy
	}
	return ""
}

func (m *RpcWalletConvertResponse) GetMnemonic() string {
	if m != nil {
		return m.Mnemonic
	}
	return ""
}

type RpcWalletConvertResponseError struct {
	Code        RpcWalletConvertResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcWalletConvertResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcWalletConvertResponseError) Reset()         { *m = RpcWalletConvertResponseError{} }
func (m *RpcWalletConvertResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcWalletConvertResponseError) ProtoMessage()    {}
func (*RpcWalletConvertResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 2, 1, 0}
}
func (m *RpcWalletConvertResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWalletConvertResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWalletConvertResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWalletConvertResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWalletConvertResponseError.Merge(m, src)
}
func (m *RpcWalletConvertResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcWalletConvertResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWalletConvertResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWalletConvertResponseError proto.InternalMessageInfo

func (m *RpcWalletConvertResponseError) GetCode() RpcWalletConvertResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWalletConvertResponseError_NULL
}

func (m *RpcWalletConvertResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Namespace, that agregates subtopics and actions, that relates to account.
type RpcAccount struct {
}

func (m *RpcAccount) Reset()         { *m = RpcAccount{} }
func (m *RpcAccount) String() string { return proto.CompactTextString(m) }
func (*RpcAccount) ProtoMessage()    {}
func (*RpcAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6}
}
func (m *RpcAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccount.Merge(m, src)
}
func (m *RpcAccount) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccount.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccount proto.InternalMessageInfo

type RpcAccountConfig struct {
	EnableDataview             bool          `protobuf:"varint,1,opt,name=enableDataview,proto3" json:"enableDataview,omitempty"`
	EnableDebug                bool          `protobuf:"varint,2,opt,name=enableDebug,proto3" json:"enableDebug,omitempty"`
	EnableReleaseChannelSwitch bool          `protobuf:"varint,3,opt,name=enableReleaseChannelSwitch,proto3" json:"enableReleaseChannelSwitch,omitempty"`
	EnableSpaces               bool          `protobuf:"varint,4,opt,name=enableSpaces,proto3" json:"enableSpaces,omitempty"`
	Extra                      *types.Struct `protobuf:"bytes,100,opt,name=extra,proto3" json:"extra,omitempty"`
}

func (m *RpcAccountConfig) Reset()         { *m = RpcAccountConfig{} }
func (m *RpcAccountConfig) String() string { return proto.CompactTextString(m) }
func (*RpcAccountConfig) ProtoMessage()    {}
func (*RpcAccountConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 0}
}
func (m *RpcAccountConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountConfig.Merge(m, src)
}
func (m *RpcAccountConfig) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountConfig.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountConfig proto.InternalMessageInfo

func (m *RpcAccountConfig) GetEnableDataview() bool {
	if m != nil {
		return m.EnableDataview
	}
	return false
}

func (m *RpcAccountConfig) GetEnableDebug() bool {
	if m != nil {
		return m.EnableDebug
	}
	return false
}

func (m *RpcAccountConfig) GetEnableReleaseChannelSwitch() bool {
	if m != nil {
		return m.EnableReleaseChannelSwitch
	}
	return false
}

func (m *RpcAccountConfig) GetEnableSpaces() bool {
	if m != nil {
		return m.EnableSpaces
	}
	return false
}

func (m *RpcAccountConfig) GetExtra() *types.Struct {
	if m != nil {
		return m.Extra
	}
	return nil
}

type RpcAccountCreate struct {
}

func (m *RpcAccountCreate) Reset()         { *m = RpcAccountCreate{} }
func (m *RpcAccountCreate) String() string { return proto.CompactTextString(m) }
func (*RpcAccountCreate) ProtoMessage()    {}
func (*RpcAccountCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 1}
}
func (m *RpcAccountCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountCreate.Merge(m, src)
}
func (m *RpcAccountCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountCreate proto.InternalMessageInfo

//*
// Front end to middleware request-to-create-an account
type RpcAccountCreateRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to Avatar:
	//	*RpcAccountCreateRequestAvatarOfAvatarLocalPath
	Avatar          IsRpcAccountCreateRequestAvatar `protobuf_oneof:"avatar"`
	AlphaInviteCode string                          `protobuf:"bytes,20,opt,name=alphaInviteCode,proto3" json:"alphaInviteCode,omitempty"`
}

func (m *RpcAccountCreateRequest) Reset()         { *m = RpcAccountCreateRequest{} }
func (m *RpcAccountCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcAccountCreateRequest) ProtoMessage()    {}
func (*RpcAccountCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 1, 0}
}
func (m *RpcAccountCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountCreateRequest.Merge(m, src)
}
func (m *RpcAccountCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountCreateRequest proto.InternalMessageInfo

type IsRpcAccountCreateRequestAvatar interface {
	IsRpcAccountCreateRequestAvatar()
	MarshalTo([]byte) (int, error)
	Size() int
}

type RpcAccountCreateRequestAvatarOfAvatarLocalPath struct {
	AvatarLocalPath string `protobuf:"bytes,2,opt,name=avatarLocalPath,proto3,oneof" json:"avatarLocalPath,omitempty"`
}

func (*RpcAccountCreateRequestAvatarOfAvatarLocalPath) IsRpcAccountCreateRequestAvatar() {}

func (m *RpcAccountCreateRequest) GetAvatar() IsRpcAccountCreateRequestAvatar {
	if m != nil {
		return m.Avatar
	}
	return nil
}

func (m *RpcAccountCreateRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RpcAccountCreateRequest) GetAvatarLocalPath() string {
	if x, ok := m.GetAvatar().(*RpcAccountCreateRequestAvatarOfAvatarLocalPath); ok {
		return x.AvatarLocalPath
	}
	return ""
}

func (m *RpcAccountCreateRequest) GetAlphaInviteCode() string {
	if m != nil {
		return m.AlphaInviteCode
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RpcAccountCreateRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RpcAccountCreateRequestAvatarOfAvatarLocalPath)(nil),
	}
}

//*
// Middleware-to-front-end response for an account creation request, that can contain a NULL error and created account or a non-NULL error and an empty account
type RpcAccountCreateResponse struct {
	Error   *RpcAccountCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Account *model.Account                 `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
	Config  *RpcAccountConfig              `protobuf:"bytes,3,opt,name=config,proto3" json:"config,omitempty"`
}

func (m *RpcAccountCreateResponse) Reset()         { *m = RpcAccountCreateResponse{} }
func (m *RpcAccountCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcAccountCreateResponse) ProtoMessage()    {}
func (*RpcAccountCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 1, 1}
}
func (m *RpcAccountCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountCreateResponse.Merge(m, src)
}
func (m *RpcAccountCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountCreateResponse proto.InternalMessageInfo

func (m *RpcAccountCreateResponse) GetError() *RpcAccountCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcAccountCreateResponse) GetAccount() *model.Account {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *RpcAccountCreateResponse) GetConfig() *RpcAccountConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

type RpcAccountCreateResponseError struct {
	Code        RpcAccountCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcAccountCreateResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcAccountCreateResponseError) Reset()         { *m = RpcAccountCreateResponseError{} }
func (m *RpcAccountCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcAccountCreateResponseError) ProtoMessage()    {}
func (*RpcAccountCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 1, 1, 0}
}
func (m *RpcAccountCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountCreateResponseError.Merge(m, src)
}
func (m *RpcAccountCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountCreateResponseError proto.InternalMessageInfo

func (m *RpcAccountCreateResponseError) GetCode() RpcAccountCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountCreateResponseError_NULL
}

func (m *RpcAccountCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcAccountRecover struct {
}

func (m *RpcAccountRecover) Reset()         { *m = RpcAccountRecover{} }
func (m *RpcAccountRecover) String() string { return proto.CompactTextString(m) }
func (*RpcAccountRecover) ProtoMessage()    {}
func (*RpcAccountRecover) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 2}
}
func (m *RpcAccountRecover) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountRecover) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountRecover.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountRecover) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountRecover.Merge(m, src)
}
func (m *RpcAccountRecover) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountRecover) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountRecover.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountRecover proto.InternalMessageInfo

//*
// Front end to middleware request-to-start-search of an accounts for a recovered mnemonic.
// Each of an account that would be found will come with an AccountAdd event
type RpcAccountRecoverRequest struct {
}

func (m *RpcAccountRecoverRequest) Reset()         { *m = RpcAccountRecoverRequest{} }
func (m *RpcAccountRecoverRequest) String() string { return proto.CompactTextString(m) }
func (*RpcAccountRecoverRequest) ProtoMessage()    {}
func (*RpcAccountRecoverRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 2, 0}
}
func (m *RpcAccountRecoverRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountRecoverRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountRecoverRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountRecoverRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountRecoverRequest.Merge(m, src)
}
func (m *RpcAccountRecoverRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountRecoverRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountRecoverRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountRecoverRequest proto.InternalMessageInfo

//*
// Middleware-to-front-end response to an account recover request, that can contain a NULL error and created account or a non-NULL error and an empty account
type RpcAccountRecoverResponse struct {
	Error *RpcAccountRecoverResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcAccountRecoverResponse) Reset()         { *m = RpcAccountRecoverResponse{} }
func (m *RpcAccountRecoverResponse) String() string { return proto.CompactTextString(m) }
func (*RpcAccountRecoverResponse) ProtoMessage()    {}
func (*RpcAccountRecoverResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 2, 1}
}
func (m *RpcAccountRecoverResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountRecoverResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountRecoverResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountRecoverResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountRecoverResponse.Merge(m, src)
}
func (m *RpcAccountRecoverResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountRecoverResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountRecoverResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountRecoverResponse proto.InternalMessageInfo

func (m *RpcAccountRecoverResponse) GetError() *RpcAccountRecoverResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcAccountRecoverResponseError struct {
	Code        RpcAccountRecoverResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcAccountRecoverResponseErrorCode" json:"code,omitempty"`
	Description string                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcAccountRecoverResponseError) Reset()         { *m = RpcAccountRecoverResponseError{} }
func (m *RpcAccountRecoverResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcAccountRecoverResponseError) ProtoMessage()    {}
func (*RpcAccountRecoverResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 2, 1, 0}
}
func (m *RpcAccountRecoverResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountRecoverResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountRecoverResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountRecoverResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountRecoverResponseError.Merge(m, src)
}
func (m *RpcAccountRecoverResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountRecoverResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountRecoverResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountRecoverResponseError proto.InternalMessageInfo

func (m *RpcAccountRecoverResponseError) GetCode() RpcAccountRecoverResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountRecoverResponseError_NULL
}

func (m *RpcAccountRecoverResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcAccountSelect struct {
}

func (m *RpcAccountSelect) Reset()         { *m = RpcAccountSelect{} }
func (m *RpcAccountSelect) String() string { return proto.CompactTextString(m) }
func (*RpcAccountSelect) ProtoMessage()    {}
func (*RpcAccountSelect) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 3}
}
func (m *RpcAccountSelect) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountSelect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountSelect.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountSelect) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountSelect.Merge(m, src)
}
func (m *RpcAccountSelect) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountSelect) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountSelect.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountSelect proto.InternalMessageInfo

//*
// Front end to middleware request-to-launch-a specific account using account id and a root path
// User can select an account from those, that came with an AccountAdd events
type RpcAccountSelectRequest struct {
	Id       string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RootPath string `protobuf:"bytes,2,opt,name=rootPath,proto3" json:"rootPath,omitempty"`
}

func (m *RpcAccountSelectRequest) Reset()         { *m = RpcAccountSelectRequest{} }
func (m *RpcAccountSelectRequest) String() string { return proto.CompactTextString(m) }
func (*RpcAccountSelectRequest) ProtoMessage()    {}
func (*RpcAccountSelectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 3, 0}
}
func (m *RpcAccountSelectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountSelectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountSelectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountSelectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountSelectRequest.Merge(m, src)
}
func (m *RpcAccountSelectRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountSelectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountSelectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountSelectRequest proto.InternalMessageInfo

func (m *RpcAccountSelectRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcAccountSelectRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

//*
// Middleware-to-front-end response for an account select request, that can contain a NULL error and selected account or a non-NULL error and an empty account
type RpcAccountSelectResponse struct {
	Error   *RpcAccountSelectResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Account *model.Account                 `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
	Config  *RpcAccountConfig              `protobuf:"bytes,3,opt,name=config,proto3" json:"config,omitempty"`
}

func (m *RpcAccountSelectResponse) Reset()         { *m = RpcAccountSelectResponse{} }
func (m *RpcAccountSelectResponse) String() string { return proto.CompactTextString(m) }
func (*RpcAccountSelectResponse) ProtoMessage()    {}
func (*RpcAccountSelectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 3, 1}
}
func (m *RpcAccountSelectResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountSelectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountSelectResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountSelectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountSelectResponse.Merge(m, src)
}
func (m *RpcAccountSelectResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountSelectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountSelectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountSelectResponse proto.InternalMessageInfo

func (m *RpcAccountSelectResponse) GetError() *RpcAccountSelectResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcAccountSelectResponse) GetAccount() *model.Account {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *RpcAccountSelectResponse) GetConfig() *RpcAccountConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

type RpcAccountSelectResponseError struct {
	Code        RpcAccountSelectResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcAccountSelectResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcAccountSelectResponseError) Reset()         { *m = RpcAccountSelectResponseError{} }
func (m *RpcAccountSelectResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcAccountSelectResponseError) ProtoMessage()    {}
func (*RpcAccountSelectResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 3, 1, 0}
}
func (m *RpcAccountSelectResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountSelectResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountSelectResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountSelectResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountSelectResponseError.Merge(m, src)
}
func (m *RpcAccountSelectResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountSelectResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountSelectResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountSelectResponseError proto.InternalMessageInfo

func (m *RpcAccountSelectResponseError) GetCode() RpcAccountSelectResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountSelectResponseError_NULL
}

func (m *RpcAccountSelectResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcAccountStop struct {
}

func (m *RpcAccountStop) Reset()         { *m = RpcAccountStop{} }
func (m *RpcAccountStop) String() string { return proto.CompactTextString(m) }
func (*RpcAccountStop) ProtoMessage()    {}
func (*RpcAccountStop) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 4}
}
func (m *RpcAccountStop) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountStop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountStop.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountStop) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountStop.Merge(m, src)
}
func (m *RpcAccountStop) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountStop) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountStop.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountStop proto.InternalMessageInfo

//*
// Front end to middleware request to stop currently running account node and optionally remove the locally stored data
type RpcAccountStopRequest struct {
	RemoveData bool `protobuf:"varint,1,opt,name=removeData,proto3" json:"removeData,omitempty"`
}

func (m *RpcAccountStopRequest) Reset()         { *m = RpcAccountStopRequest{} }
func (m *RpcAccountStopRequest) String() string { return proto.CompactTextString(m) }
func (*RpcAccountStopRequest) ProtoMessage()    {}
func (*RpcAccountStopRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 4, 0}
}
func (m *RpcAccountStopRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountStopRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountStopRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountStopRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountStopRequest.Merge(m, src)
}
func (m *RpcAccountStopRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountStopRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountStopRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountStopRequest proto.InternalMessageInfo

func (m *RpcAccountStopRequest) GetRemoveData() bool {
	if m != nil {
		return m.RemoveData
	}
	return false
}

//*
// Middleware-to-front-end response for an account stop request
type RpcAccountStopResponse struct {
	Error *RpcAccountStopResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcAccountStopResponse) Reset()         { *m = RpcAccountStopResponse{} }
func (m *RpcAccountStopResponse) String() string { return proto.CompactTextString(m) }
func (*RpcAccountStopResponse) ProtoMessage()    {}
func (*RpcAccountStopResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 4, 1}
}
func (m *RpcAccountStopResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountStopResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountStopResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountStopResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountStopResponse.Merge(m, src)
}
func (m *RpcAccountStopResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountStopResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountStopResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountStopResponse proto.InternalMessageInfo

func (m *RpcAccountStopResponse) GetError() *RpcAccountStopResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcAccountStopResponseError struct {
	Code        RpcAccountStopResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcAccountStopResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcAccountStopResponseError) Reset()         { *m = RpcAccountStopResponseError{} }
func (m *RpcAccountStopResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcAccountStopResponseError) ProtoMessage()    {}
func (*RpcAccountStopResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 6, 4, 1, 0}
}
func (m *RpcAccountStopResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountStopResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountStopResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountStopResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountStopResponseError.Merge(m, src)
}
func (m *RpcAccountStopResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountStopResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountStopResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountStopResponseError proto.InternalMessageInfo

func (m *RpcAccountStopResponseError) GetCode() RpcAccountStopResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountStopResponseError_NULL
}

func (m *RpcAccountStopResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Namespace, that agregates log subtopics and actions.
// Usage: send request with topic (Level) and description (message) from client to middleware to log.
type RpcLog struct {
}

func (m *RpcLog) Reset()         { *m = RpcLog{} }
func (m *RpcLog) String() string { return proto.CompactTextString(m) }
func (*RpcLog) ProtoMessage()    {}
func (*RpcLog) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7}
}
func (m *RpcLog) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLog.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLog.Merge(m, src)
}
func (m *RpcLog) XXX_Size() int {
	return m.Size()
}
func (m *RpcLog) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLog.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLog proto.InternalMessageInfo

type RpcLogSend struct {
}

func (m *RpcLogSend) Reset()         { *m = RpcLogSend{} }
func (m *RpcLogSend) String() string { return proto.CompactTextString(m) }
func (*RpcLogSend) ProtoMessage()    {}
func (*RpcLogSend) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7, 0}
}
func (m *RpcLogSend) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLogSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLogSend.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLogSend) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLogSend.Merge(m, src)
}
func (m *RpcLogSend) XXX_Size() int {
	return m.Size()
}
func (m *RpcLogSend) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLogSend.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLogSend proto.InternalMessageInfo

type RpcLogSendRequest struct {
	Message string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	Level   RpcLogSendRequestLevel `protobuf:"varint,2,opt,name=level,proto3,enum=anytype.RpcLogSendRequestLevel" json:"level,omitempty"`
}

func (m *RpcLogSendRequest) Reset()         { *m = RpcLogSendRequest{} }
func (m *RpcLogSendRequest) String() string { return proto.CompactTextString(m) }
func (*RpcLogSendRequest) ProtoMessage()    {}
func (*RpcLogSendRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7, 0, 0}
}
func (m *RpcLogSendRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLogSendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLogSendRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLogSendRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLogSendRequest.Merge(m, src)
}
func (m *RpcLogSendRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcLogSendRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLogSendRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLogSendRequest proto.InternalMessageInfo

func (m *RpcLogSendRequest) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *RpcLogSendRequest) GetLevel() RpcLogSendRequestLevel {
	if m != nil {
		return m.Level
	}
	return RpcLogSendRequest_DEBUG
}

type RpcLogSendResponse struct {
	Error *RpcLogSendResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcLogSendResponse) Reset()         { *m = RpcLogSendResponse{} }
func (m *RpcLogSendResponse) String() string { return proto.CompactTextString(m) }
func (*RpcLogSendResponse) ProtoMessage()    {}
func (*RpcLogSendResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7, 0, 1}
}
func (m *RpcLogSendResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLogSendResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLogSendResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLogSendResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLogSendResponse.Merge(m, src)
}
func (m *RpcLogSendResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcLogSendResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLogSendResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLogSendResponse proto.InternalMessageInfo

func (m *RpcLogSendResponse) GetError() *RpcLogSendResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcLogSendResponseError struct {
	Code        RpcLogSendResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcLogSendResponseErrorCode" json:"code,omitempty"`
	Description string                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcLogSendResponseError) Reset()         { *m = RpcLogSendResponseError{} }
func (m *RpcLogSendResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcLogSendResponseError) ProtoMessage()    {}
func (*RpcLogSendResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 7, 0, 1, 0}
}
func (m *RpcLogSendResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLogSendResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLogSendResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLogSendResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLogSendResponseError.Merge(m, src)
}
func (m *RpcLogSendResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcLogSendResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLogSendResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLogSendResponseError proto.InternalMessageInfo

func (m *RpcLogSendResponseError) GetCode() RpcLogSendResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcLogSendResponseError_NULL
}

func (m *RpcLogSendResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Get info about a version of a middleware.
// Info is a string, that contains: BuildDate, GitCommit, GitBranch, GitState
type RpcVersion struct {
}

func (m *RpcVersion) Reset()         { *m = RpcVersion{} }
func (m *RpcVersion) String() string { return proto.CompactTextString(m) }
func (*RpcVersion) ProtoMessage()    {}
func (*RpcVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8}
}
func (m *RpcVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcVersion.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcVersion.Merge(m, src)
}
func (m *RpcVersion) XXX_Size() int {
	return m.Size()
}
func (m *RpcVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcVersion.DiscardUnknown(m)
}

var xxx_messageInfo_RpcVersion proto.InternalMessageInfo

type RpcVersionGet struct {
}

func (m *RpcVersionGet) Reset()         { *m = RpcVersionGet{} }
func (m *RpcVersionGet) String() string { return proto.CompactTextString(m) }
func (*RpcVersionGet) ProtoMessage()    {}
func (*RpcVersionGet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 0}
}
func (m *RpcVersionGet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcVersionGet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcVersionGet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcVersionGet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcVersionGet.Merge(m, src)
}
func (m *RpcVersionGet) XXX_Size() int {
	return m.Size()
}
func (m *RpcVersionGet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcVersionGet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcVersionGet proto.InternalMessageInfo

type RpcVersionGetRequest struct {
}

func (m *RpcVersionGetRequest) Reset()         { *m = RpcVersionGetRequest{} }
func (m *RpcVersionGetRequest) String() string { return proto.CompactTextString(m) }
func (*RpcVersionGetRequest) ProtoMessage()    {}
func (*RpcVersionGetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 0, 0}
}
func (m *RpcVersionGetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcVersionGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcVersionGetRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcVersionGetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcVersionGetRequest.Merge(m, src)
}
func (m *RpcVersionGetRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcVersionGetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcVersionGetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcVersionGetRequest proto.InternalMessageInfo

type RpcVersionGetResponse struct {
	Error   *RpcVersionGetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Version string                      `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	Details string                      `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
}

func (m *RpcVersionGetResponse) Reset()         { *m = RpcVersionGetResponse{} }
func (m *RpcVersionGetResponse) String() string { return proto.CompactTextString(m) }
func (*RpcVersionGetResponse) ProtoMessage()    {}
func (*RpcVersionGetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 0, 1}
}
func (m *RpcVersionGetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcVersionGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcVersionGetResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcVersionGetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcVersionGetResponse.Merge(m, src)
}
func (m *RpcVersionGetResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcVersionGetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcVersionGetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcVersionGetResponse proto.InternalMessageInfo

func (m *RpcVersionGetResponse) GetError() *RpcVersionGetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcVersionGetResponse) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *RpcVersionGetResponse) GetDetails() string {
	if m != nil {
		return m.Details
	}
	return ""
}

type RpcVersionGetResponseError struct {
	Code        RpcVersionGetResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcVersionGetResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcVersionGetResponseError) Reset()         { *m = RpcVersionGetResponseError{} }
func (m *RpcVersionGetResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcVersionGetResponseError) ProtoMessage()    {}
func (*RpcVersionGetResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 0, 1, 0}
}
func (m *RpcVersionGetResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcVersionGetResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcVersionGetResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcVersionGetResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcVersionGetResponseError.Merge(m, src)
}
func (m *RpcVersionGetResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcVersionGetResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcVersionGetResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcVersionGetResponseError proto.InternalMessageInfo

func (m *RpcVersionGetResponseError) GetCode() RpcVersionGetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcVersionGetResponseError_NULL
}

func (m *RpcVersionGetResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcFile struct {
}

func (m *RpcFile) Reset()         { *m = RpcFile{} }
func (m *RpcFile) String() string { return proto.CompactTextString(m) }
func (*RpcFile) ProtoMessage()    {}
func (*RpcFile) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9}
}
func (m *RpcFile) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFile.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFile.Merge(m, src)
}
func (m *RpcFile) XXX_Size() int {
	return m.Size()
}
func (m *RpcFile) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFile.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFile proto.InternalMessageInfo

type RpcFileOffload struct {
}

func (m *RpcFileOffload) Reset()         { *m = RpcFileOffload{} }
func (m *RpcFileOffload) String() string { return proto.CompactTextString(m) }
func (*RpcFileOffload) ProtoMessage()    {}
func (*RpcFileOffload) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 0}
}
func (m *RpcFileOffload) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileOffload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileOffload.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileOffload) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileOffload.Merge(m, src)
}
func (m *RpcFileOffload) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileOffload) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileOffload.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileOffload proto.InternalMessageInfo

type RpcFileOffloadRequest struct {
	Id               string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	IncludeNotPinned bool   `protobuf:"varint,2,opt,name=includeNotPinned,proto3" json:"includeNotPinned,omitempty"`
}

func (m *RpcFileOffloadRequest) Reset()         { *m = RpcFileOffloadRequest{} }
func (m *RpcFileOffloadRequest) String() string { return proto.CompactTextString(m) }
func (*RpcFileOffloadRequest) ProtoMessage()    {}
func (*RpcFileOffloadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 0, 0}
}
func (m *RpcFileOffloadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileOffloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileOffloadRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileOffloadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileOffloadRequest.Merge(m, src)
}
func (m *RpcFileOffloadRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileOffloadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileOffloadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileOffloadRequest proto.InternalMessageInfo

func (m *RpcFileOffloadRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcFileOffloadRequest) GetIncludeNotPinned() bool {
	if m != nil {
		return m.IncludeNotPinned
	}
	return false
}

type RpcFileOffloadResponse struct {
	Error          *RpcFileOffloadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	BytesOffloaded uint64                       `protobuf:"varint,2,opt,name=bytesOffloaded,proto3" json:"bytesOffloaded,omitempty"`
}

func (m *RpcFileOffloadResponse) Reset()         { *m = RpcFileOffloadResponse{} }
func (m *RpcFileOffloadResponse) String() string { return proto.CompactTextString(m) }
func (*RpcFileOffloadResponse) ProtoMessage()    {}
func (*RpcFileOffloadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 0, 1}
}
func (m *RpcFileOffloadResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileOffloadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileOffloadResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileOffloadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileOffloadResponse.Merge(m, src)
}
func (m *RpcFileOffloadResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileOffloadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileOffloadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileOffloadResponse proto.InternalMessageInfo

func (m *RpcFileOffloadResponse) GetError() *RpcFileOffloadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcFileOffloadResponse) GetBytesOffloaded() uint64 {
	if m != nil {
		return m.BytesOffloaded
	}
	return 0
}

type RpcFileOffloadResponseError struct {
	Code        RpcFileOffloadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcFileOffloadResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcFileOffloadResponseError) Reset()         { *m = RpcFileOffloadResponseError{} }
func (m *RpcFileOffloadResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcFileOffloadResponseError) ProtoMessage()    {}
func (*RpcFileOffloadResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 0, 1, 0}
}
func (m *RpcFileOffloadResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileOffloadResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileOffloadResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileOffloadResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileOffloadResponseError.Merge(m, src)
}
func (m *RpcFileOffloadResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileOffloadResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileOffloadResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileOffloadResponseError proto.InternalMessageInfo

func (m *RpcFileOffloadResponseError) GetCode() RpcFileOffloadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcFileOffloadResponseError_NULL
}

func (m *RpcFileOffloadResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcFileList struct {
}

func (m *RpcFileList) Reset()         { *m = RpcFileList{} }
func (m *RpcFileList) String() string { return proto.CompactTextString(m) }
func (*RpcFileList) ProtoMessage()    {}
func (*RpcFileList) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 10}
}
func (m *RpcFileList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileList.Merge(m, src)
}
func (m *RpcFileList) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileList) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileList.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileList proto.InternalMessageInfo

type RpcFileListOffload struct {
}

func (m *RpcFileListOffload) Reset()         { *m = RpcFileListOffload{} }
func (m *RpcFileListOffload) String() string { return proto.CompactTextString(m) }
func (*RpcFileListOffload) ProtoMessage()    {}
func (*RpcFileListOffload) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 10, 0}
}
func (m *RpcFileListOffload) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileListOffload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileListOffload.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileListOffload) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileListOffload.Merge(m, src)
}
func (m *RpcFileListOffload) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileListOffload) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileListOffload.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileListOffload proto.InternalMessageInfo

type RpcFileListOffloadRequest struct {
	OnlyIds          []string `protobuf:"bytes,1,rep,name=onlyIds,proto3" json:"onlyIds,omitempty"`
	IncludeNotPinned bool     `protobuf:"varint,2,opt,name=includeNotPinned,proto3" json:"includeNotPinned,omitempty"`
}

func (m *RpcFileListOffloadRequest) Reset()         { *m = RpcFileListOffloadRequest{} }
func (m *RpcFileListOffloadRequest) String() string { return proto.CompactTextString(m) }
func (*RpcFileListOffloadRequest) ProtoMessage()    {}
func (*RpcFileListOffloadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 10, 0, 0}
}
func (m *RpcFileListOffloadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileListOffloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileListOffloadRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileListOffloadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileListOffloadRequest.Merge(m, src)
}
func (m *RpcFileListOffloadRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileListOffloadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileListOffloadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileListOffloadRequest proto.InternalMessageInfo

func (m *RpcFileListOffloadRequest) GetOnlyIds() []string {
	if m != nil {
		return m.OnlyIds
	}
	return nil
}

func (m *RpcFileListOffloadRequest) GetIncludeNotPinned() bool {
	if m != nil {
		return m.IncludeNotPinned
	}
	return false
}

type RpcFileListOffloadResponse struct {
	Error          *RpcFileListOffloadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	FilesOffloaded int32                            `protobuf:"varint,2,opt,name=filesOffloaded,proto3" json:"filesOffloaded,omitempty"`
	BytesOffloaded uint64                           `protobuf:"varint,3,opt,name=bytesOffloaded,proto3" json:"bytesOffloaded,omitempty"`
}

func (m *RpcFileListOffloadResponse) Reset()         { *m = RpcFileListOffloadResponse{} }
func (m *RpcFileListOffloadResponse) String() string { return proto.CompactTextString(m) }
func (*RpcFileListOffloadResponse) ProtoMessage()    {}
func (*RpcFileListOffloadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 10, 0, 1}
}
func (m *RpcFileListOffloadResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileListOffloadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileListOffloadResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileListOffloadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileListOffloadResponse.Merge(m, src)
}
func (m *RpcFileListOffloadResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileListOffloadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileListOffloadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileListOffloadResponse proto.InternalMessageInfo

func (m *RpcFileListOffloadResponse) GetError() *RpcFileListOffloadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcFileListOffloadResponse) GetFilesOffloaded() int32 {
	if m != nil {
		return m.FilesOffloaded
	}
	return 0
}

func (m *RpcFileListOffloadResponse) GetBytesOffloaded() uint64 {
	if m != nil {
		return m.BytesOffloaded
	}
	return 0
}

type RpcFileListOffloadResponseError struct {
	Code        RpcFileListOffloadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcFileListOffloadResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcFileListOffloadResponseError) Reset()         { *m = RpcFileListOffloadResponseError{} }
func (m *RpcFileListOffloadResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcFileListOffloadResponseError) ProtoMessage()    {}
func (*RpcFileListOffloadResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 10, 0, 1, 0}
}
func (m *RpcFileListOffloadResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileListOffloadResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileListOffloadResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileListOffloadResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileListOffloadResponseError.Merge(m, src)
}
func (m *RpcFileListOffloadResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileListOffloadResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileListOffloadResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileListOffloadResponseError proto.InternalMessageInfo

func (m *RpcFileListOffloadResponseError) GetCode() RpcFileListOffloadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcFileListOffloadResponseError_NULL
}

func (m *RpcFileListOffloadResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcShutdown struct {
}

func (m *RpcShutdown) Reset()         { *m = RpcShutdown{} }
func (m *RpcShutdown) String() string { return proto.CompactTextString(m) }
func (*RpcShutdown) ProtoMessage()    {}
func (*RpcShutdown) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11}
}
func (m *RpcShutdown) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcShutdown) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcShutdown.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcShutdown) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcShutdown.Merge(m, src)
}
func (m *RpcShutdown) XXX_Size() int {
	return m.Size()
}
func (m *RpcShutdown) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcShutdown.DiscardUnknown(m)
}

var xxx_messageInfo_RpcShutdown proto.InternalMessageInfo

type RpcShutdownRequest struct {
}

func (m *RpcShutdownRequest) Reset()         { *m = RpcShutdownRequest{} }
func (m *RpcShutdownRequest) String() string { return proto.CompactTextString(m) }
func (*RpcShutdownRequest) ProtoMessage()    {}
func (*RpcShutdownRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 0}
}
func (m *RpcShutdownRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcShutdownRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcShutdownRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcShutdownRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcShutdownRequest.Merge(m, src)
}
func (m *RpcShutdownRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcShutdownRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcShutdownRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcShutdownRequest proto.InternalMessageInfo

type RpcShutdownResponse struct {
	Error *RpcShutdownResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcShutdownResponse) Reset()         { *m = RpcShutdownResponse{} }
func (m *RpcShutdownResponse) String() string { return proto.CompactTextString(m) }
func (*RpcShutdownResponse) ProtoMessage()    {}
func (*RpcShutdownResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 1}
}
func (m *RpcShutdownResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcShutdownResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcShutdownResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcShutdownResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcShutdownResponse.Merge(m, src)
}
func (m *RpcShutdownResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcShutdownResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcShutdownResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcShutdownResponse proto.InternalMessageInfo

func (m *RpcShutdownResponse) GetError() *RpcShutdownResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcShutdownResponseError struct {
	Code        RpcShutdownResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcShutdownResponseErrorCode" json:"code,omitempty"`
	Description string                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcShutdownResponseError) Reset()         { *m = RpcShutdownResponseError{} }
func (m *RpcShutdownResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcShutdownResponseError) ProtoMessage()    {}
func (*RpcShutdownResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 1, 0}
}
func (m *RpcShutdownResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcShutdownResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcShutdownResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcShutdownResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcShutdownResponseError.Merge(m, src)
}
func (m *RpcShutdownResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcShutdownResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcShutdownResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcShutdownResponseError proto.InternalMessageInfo

func (m *RpcShutdownResponseError) GetCode() RpcShutdownResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcShutdownResponseError_NULL
}

func (m *RpcShutdownResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcConfig struct {
}

func (m *RpcConfig) Reset()         { *m = RpcConfig{} }
func (m *RpcConfig) String() string { return proto.CompactTextString(m) }
func (*RpcConfig) ProtoMessage()    {}
func (*RpcConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 12}
}
func (m *RpcConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcConfig.Merge(m, src)
}
func (m *RpcConfig) XXX_Size() int {
	return m.Size()
}
func (m *RpcConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcConfig.DiscardUnknown(m)
}

var xxx_messageInfo_RpcConfig proto.InternalMessageInfo

type RpcConfigGet struct {
}

func (m *RpcConfigGet) Reset()         { *m = RpcConfigGet{} }
func (m *RpcConfigGet) String() string { return proto.CompactTextString(m) }
func (*RpcConfigGet) ProtoMessage()    {}
func (*RpcConfigGet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 12, 0}
}
func (m *RpcConfigGet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcConfigGet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcConfigGet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcConfigGet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcConfigGet.Merge(m, src)
}
func (m *RpcConfigGet) XXX_Size() int {
	return m.Size()
}
func (m *RpcConfigGet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcConfigGet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcConfigGet proto.InternalMessageInfo

type RpcConfigGetRequest struct {
}

func (m *RpcConfigGetRequest) Reset()         { *m = RpcConfigGetRequest{} }
func (m *RpcConfigGetRequest) String() string { return proto.CompactTextString(m) }
func (*RpcConfigGetRequest) ProtoMessage()    {}
func (*RpcConfigGetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 12, 0, 0}
}
func (m *RpcConfigGetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcConfigGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcConfigGetRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcConfigGetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcConfigGetRequest.Merge(m, src)
}
func (m *RpcConfigGetRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcConfigGetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcConfigGetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcConfigGetRequest proto.InternalMessageInfo

type RpcConfigGetResponse struct {
	Error                 *RpcConfigGetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	HomeBlockId           string                     `protobuf:"bytes,2,opt,name=homeBlockId,proto3" json:"homeBlockId,omitempty"`
	ArchiveBlockId        string                     `protobuf:"bytes,3,opt,name=archiveBlockId,proto3" json:"archiveBlockId,omitempty"`
	ProfileBlockId        string                     `protobuf:"bytes,4,opt,name=profileBlockId,proto3" json:"profileBlockId,omitempty"`
	MarketplaceTypeId     string                     `protobuf:"bytes,5,opt,name=marketplaceTypeId,proto3" json:"marketplaceTypeId,omitempty"`
	MarketplaceRelationId string                     `protobuf:"bytes,6,opt,name=marketplaceRelationId,proto3" json:"marketplaceRelationId,omitempty"`
	MarketplaceTemplateId string                     `protobuf:"bytes,7,opt,name=marketplaceTemplateId,proto3" json:"marketplaceTemplateId,omitempty"`
	DeviceId              string                     `protobuf:"bytes,8,opt,name=deviceId,proto3" json:"deviceId,omitempty"`
	GatewayUrl            string                     `protobuf:"bytes,101,opt,name=gatewayUrl,proto3" json:"gatewayUrl,omitempty"`
}

func (m *RpcConfigGetResponse) Reset()         { *m = RpcConfigGetResponse{} }
func (m *RpcConfigGetResponse) String() string { return proto.CompactTextString(m) }
func (*RpcConfigGetResponse) ProtoMessage()    {}
func (*RpcConfigGetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 12, 0, 1}
}
func (m *RpcConfigGetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcConfigGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcConfigGetResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcConfigGetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcConfigGetResponse.Merge(m, src)
}
func (m *RpcConfigGetResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcConfigGetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcConfigGetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcConfigGetResponse proto.InternalMessageInfo

func (m *RpcConfigGetResponse) GetError() *RpcConfigGetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcConfigGetResponse) GetHomeBlockId() string {
	if m != nil {
		return m.HomeBlockId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetArchiveBlockId() string {
	if m != nil {
		return m.ArchiveBlockId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetProfileBlockId() string {
	if m != nil {
		return m.ProfileBlockId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetMarketplaceTypeId() string {
	if m != nil {
		return m.MarketplaceTypeId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetMarketplaceRelationId() string {
	if m != nil {
		return m.MarketplaceRelationId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetMarketplaceTemplateId() string {
	if m != nil {
		return m.MarketplaceTemplateId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *RpcConfigGetResponse) GetGatewayUrl() string {
	if m != nil {
		return m.GatewayUrl
	}
	return ""
}

type RpcConfigGetResponseError struct {
	Code        RpcConfigGetResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcConfigGetResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcConfigGetResponseError) Reset()         { *m = RpcConfigGetResponseError{} }
func (m *RpcConfigGetResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcConfigGetResponseError) ProtoMessage()    {}
func (*RpcConfigGetResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 12, 0, 1, 0}
}
func (m *RpcConfigGetResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcConfigGetResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcConfigGetResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcConfigGetResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcConfigGetResponseError.Merge(m, src)
}
func (m *RpcConfigGetResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcConfigGetResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcConfigGetResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcConfigGetResponseError proto.InternalMessageInfo

func (m *RpcConfigGetResponseError) GetCode() RpcConfigGetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcConfigGetResponseError_NULL
}

func (m *RpcConfigGetResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcPing struct {
}

func (m *RpcPing) Reset()         { *m = RpcPing{} }
func (m *RpcPing) String() string { return proto.CompactTextString(m) }
func (*RpcPing) ProtoMessage()    {}
func (*RpcPing) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 13}
}
func (m *RpcPing) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPing.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPing) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPing.Merge(m, src)
}
func (m *RpcPing) XXX_Size() int {
	return m.Size()
}
func (m *RpcPing) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPing.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPing proto.InternalMessageInfo

type RpcPingRequest struct {
	Index                int32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	NumberOfEventsToSend int32 `protobuf:"varint,2,opt,name=numberOfEventsToSend,proto3" json:"numberOfEventsToSend,omitempty"`
}

func (m *RpcPingRequest) Reset()         { *m = RpcPingRequest{} }
func (m *RpcPingRequest) String() string { return proto.CompactTextString(m) }
func (*RpcPingRequest) ProtoMessage()    {}
func (*RpcPingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 13, 0}
}
func (m *RpcPingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPingRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPingRequest.Merge(m, src)
}
func (m *RpcPingRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcPingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPingRequest proto.InternalMessageInfo

func (m *RpcPingRequest) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *RpcPingRequest) GetNumberOfEventsToSend() int32 {
	if m != nil {
		return m.NumberOfEventsToSend
	}
	return 0
}

type RpcPingResponse struct {
	Error *RpcPingResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Index int32                 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *RpcPingResponse) Reset()         { *m = RpcPingResponse{} }
func (m *RpcPingResponse) String() string { return proto.CompactTextString(m) }
func (*RpcPingResponse) ProtoMessage()    {}
func (*RpcPingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 13, 1}
}
func (m *RpcPingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPingResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPingResponse.Merge(m, src)
}
func (m *RpcPingResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcPingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPingResponse proto.InternalMessageInfo

func (m *RpcPingResponse) GetError() *RpcPingResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcPingResponse) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

type RpcPingResponseError struct {
	Code        RpcPingResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcPingResponseErrorCode" json:"code,omitempty"`
	Description string                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcPingResponseError) Reset()         { *m = RpcPingResponseError{} }
func (m *RpcPingResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcPingResponseError) ProtoMessage()    {}
func (*RpcPingResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 13, 1, 0}
}
func (m *RpcPingResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPingResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPingResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPingResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPingResponseError.Merge(m, src)
}
func (m *RpcPingResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcPingResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPingResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPingResponseError proto.InternalMessageInfo

func (m *RpcPingResponseError) GetCode() RpcPingResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcPingResponseError_NULL
}

func (m *RpcPingResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcProcess struct {
}

func (m *RpcProcess) Reset()         { *m = RpcProcess{} }
func (m *RpcProcess) String() string { return proto.CompactTextString(m) }
func (*RpcProcess) ProtoMessage()    {}
func (*RpcProcess) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14}
}
func (m *RpcProcess) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcProcess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcProcess.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcProcess) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcProcess.Merge(m, src)
}
func (m *RpcProcess) XXX_Size() int {
	return m.Size()
}
func (m *RpcProcess) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcProcess.DiscardUnknown(m)
}

var xxx_messageInfo_RpcProcess proto.InternalMessageInfo

type RpcProcessCancel struct {
}

func (m *RpcProcessCancel) Reset()         { *m = RpcProcessCancel{} }
func (m *RpcProcessCancel) String() string { return proto.CompactTextString(m) }
func (*RpcProcessCancel) ProtoMessage()    {}
func (*RpcProcessCancel) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 0}
}
func (m *RpcProcessCancel) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcProcessCancel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcProcessCancel.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcProcessCancel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcProcessCancel.Merge(m, src)
}
func (m *RpcProcessCancel) XXX_Size() int {
	return m.Size()
}
func (m *RpcProcessCancel) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcProcessCancel.DiscardUnknown(m)
}

var xxx_messageInfo_RpcProcessCancel proto.InternalMessageInfo

type RpcProcessCancelRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RpcProcessCancelRequest) Reset()         { *m = RpcProcessCancelRequest{} }
func (m *RpcProcessCancelRequest) String() string { return proto.CompactTextString(m) }
func (*RpcProcessCancelRequest) ProtoMessage()    {}
func (*RpcProcessCancelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 0, 0}
}
func (m *RpcProcessCancelRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcProcessCancelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcProcessCancelRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcProcessCancelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcProcessCancelRequest.Merge(m, src)
}
func (m *RpcProcessCancelRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcProcessCancelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcProcessCancelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcProcessCancelRequest proto.InternalMessageInfo

func (m *RpcProcessCancelRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type RpcProcessCancelResponse struct {
	Error *RpcProcessCancelResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcProcessCancelResponse) Reset()         { *m = RpcProcessCancelResponse{} }
func (m *RpcProcessCancelResponse) String() string { return proto.CompactTextString(m) }
func (*RpcProcessCancelResponse) ProtoMessage()    {}
func (*RpcProcessCancelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 0, 1}
}
func (m *RpcProcessCancelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcProcessCancelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcProcessCancelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcProcessCancelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcProcessCancelResponse.Merge(m, src)
}
func (m *RpcProcessCancelResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcProcessCancelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcProcessCancelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcProcessCancelResponse proto.InternalMessageInfo

func (m *RpcProcessCancelResponse) GetError() *RpcProcessCancelResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcProcessCancelResponseError struct {
	Code        RpcProcessCancelResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcProcessCancelResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcProcessCancelResponseError) Reset()         { *m = RpcProcessCancelResponseError{} }
func (m *RpcProcessCancelResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcProcessCancelResponseError) ProtoMessage()    {}
func (*RpcProcessCancelResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 0, 1, 0}
}
func (m *RpcProcessCancelResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcProcessCancelResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcProcessCancelResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcProcessCancelResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcProcessCancelResponseError.Merge(m, src)
}
func (m *RpcProcessCancelResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcProcessCancelResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcProcessCancelResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcProcessCancelResponseError proto.InternalMessageInfo

func (m *RpcProcessCancelResponseError) GetCode() RpcProcessCancelResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcProcessCancelResponseError_NULL
}

func (m *RpcProcessCancelResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcLinkPreview struct {
}

func (m *RpcLinkPreview) Reset()         { *m = RpcLinkPreview{} }
func (m *RpcLinkPreview) String() string { return proto.CompactTextString(m) }
func (*RpcLinkPreview) ProtoMessage()    {}
func (*RpcLinkPreview) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 15}
}
func (m *RpcLinkPreview) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLinkPreview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLinkPreview.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLinkPreview) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLinkPreview.Merge(m, src)
}
func (m *RpcLinkPreview) XXX_Size() int {
	return m.Size()
}
func (m *RpcLinkPreview) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLinkPreview.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLinkPreview proto.InternalMessageInfo

type RpcLinkPreviewRequest struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
}

func (m *RpcLinkPreviewRequest) Reset()         { *m = RpcLinkPreviewRequest{} }
func (m *RpcLinkPreviewRequest) String() string { return proto.CompactTextString(m) }
func (*RpcLinkPreviewRequest) ProtoMessage()    {}
func (*RpcLinkPreviewRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 15, 0}
}
func (m *RpcLinkPreviewRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLinkPreviewRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLinkPreviewRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLinkPreviewRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLinkPreviewRequest.Merge(m, src)
}
func (m *RpcLinkPreviewRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcLinkPreviewRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLinkPreviewRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLinkPreviewRequest proto.InternalMessageInfo

func (m *RpcLinkPreviewRequest) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type RpcLinkPreviewResponse struct {
	Error       *RpcLinkPreviewResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LinkPreview *model.LinkPreview           `protobuf:"bytes,2,opt,name=linkPreview,proto3" json:"linkPreview,omitempty"`
}

func (m *RpcLinkPreviewResponse) Reset()         { *m = RpcLinkPreviewResponse{} }
func (m *RpcLinkPreviewResponse) String() string { return proto.CompactTextString(m) }
func (*RpcLinkPreviewResponse) ProtoMessage()    {}
func (*RpcLinkPreviewResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 15, 1}
}
func (m *RpcLinkPreviewResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLinkPreviewResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLinkPreviewResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLinkPreviewResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLinkPreviewResponse.Merge(m, src)
}
func (m *RpcLinkPreviewResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcLinkPreviewResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLinkPreviewResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLinkPreviewResponse proto.InternalMessageInfo

func (m *RpcLinkPreviewResponse) GetError() *RpcLinkPreviewResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcLinkPreviewResponse) GetLinkPreview() *model.LinkPreview {
	if m != nil {
		return m.LinkPreview
	}
	return nil
}

type RpcLinkPreviewResponseError struct {
	Code        RpcLinkPreviewResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcLinkPreviewResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcLinkPreviewResponseError) Reset()         { *m = RpcLinkPreviewResponseError{} }
func (m *RpcLinkPreviewResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcLinkPreviewResponseError) ProtoMessage()    {}
func (*RpcLinkPreviewResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 15, 1, 0}
}
func (m *RpcLinkPreviewResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcLinkPreviewResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcLinkPreviewResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcLinkPreviewResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcLinkPreviewResponseError.Merge(m, src)
}
func (m *RpcLinkPreviewResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcLinkPreviewResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcLinkPreviewResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcLinkPreviewResponseError proto.InternalMessageInfo

func (m *RpcLinkPreviewResponseError) GetCode() RpcLinkPreviewResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcLinkPreviewResponseError_NULL
}

func (m *RpcLinkPreviewResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcUploadFile struct {
}

func (m *RpcUploadFile) Reset()         { *m = RpcUploadFile{} }
func (m *RpcUploadFile) String() string { return proto.CompactTextString(m) }
func (*RpcUploadFile) ProtoMessage()    {}
func (*RpcUploadFile) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16}
}
func (m *RpcUploadFile) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUploadFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUploadFile.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUploadFile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUploadFile.Merge(m, src)
}
func (m *RpcUploadFile) XXX_Size() int {
	return m.Size()
}
func (m *RpcUploadFile) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUploadFile.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUploadFile proto.InternalMessageInfo

type RpcUploadFileRequest struct {
	Url               string                      `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	LocalPath         string                      `protobuf:"bytes,2,opt,name=localPath,proto3" json:"localPath,omitempty"`
	Type              model.BlockContentFileType  `protobuf:"varint,3,opt,name=type,proto3,enum=anytype.model.BlockContentFileType" json:"type,omitempty"`
	DisableEncryption bool                        `protobuf:"varint,4,opt,name=disableEncryption,proto3" json:"disableEncryption,omitempty"`
	Style             model.BlockContentFileStyle `protobuf:"varint,5,opt,name=style,proto3,enum=anytype.model.BlockContentFileStyle" json:"style,omitempty"`
}

func (m *RpcUploadFileRequest) Reset()         { *m = RpcUploadFileRequest{} }
func (m *RpcUploadFileRequest) String() string { return proto.CompactTextString(m) }
func (*RpcUploadFileRequest) ProtoMessage()    {}
func (*RpcUploadFileRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 0}
}
func (m *RpcUploadFileRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUploadFileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUploadFileRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUploadFileRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUploadFileRequest.Merge(m, src)
}
func (m *RpcUploadFileRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcUploadFileRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUploadFileRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUploadFileRequest proto.InternalMessageInfo

func (m *RpcUploadFileRequest) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *RpcUploadFileRequest) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

func (m *RpcUploadFileRequest) GetType() model.BlockContentFileType {
	if m != nil {
		return m.Type
	}
	return model.BlockContentFile_None
}

func (m *RpcUploadFileRequest) GetDisableEncryption() bool {
	if m != nil {
		return m.DisableEncryption
	}
	return false
}

func (m *RpcUploadFileRequest) GetStyle() model.BlockContentFileStyle {
	if m != nil {
		return m.Style
	}
	return model.BlockContentFile_Auto
}

type RpcUploadFileResponse struct {
	Error *RpcUploadFileResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Hash  string                      `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *RpcUploadFileResponse) Reset()         { *m = RpcUploadFileResponse{} }
func (m *RpcUploadFileResponse) String() string { return proto.CompactTextString(m) }
func (*RpcUploadFileResponse) ProtoMessage()    {}
func (*RpcUploadFileResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 1}
}
func (m *RpcUploadFileResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUploadFileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUploadFileResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUploadFileResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUploadFileResponse.Merge(m, src)
}
func (m *RpcUploadFileResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcUploadFileResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUploadFileResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUploadFileResponse proto.InternalMessageInfo

func (m *RpcUploadFileResponse) GetError() *RpcUploadFileResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcUploadFileResponse) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

type RpcUploadFileResponseError struct {
	Code        RpcUploadFileResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcUploadFileResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcUploadFileResponseError) Reset()         { *m = RpcUploadFileResponseError{} }
func (m *RpcUploadFileResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcUploadFileResponseError) ProtoMessage()    {}
func (*RpcUploadFileResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 1, 0}
}
func (m *RpcUploadFileResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUploadFileResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUploadFileResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUploadFileResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUploadFileResponseError.Merge(m, src)
}
func (m *RpcUploadFileResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcUploadFileResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUploadFileResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUploadFileResponseError proto.InternalMessageInfo

func (m *RpcUploadFileResponseError) GetCode() RpcUploadFileResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcUploadFileResponseError_NULL
}

func (m *RpcUploadFileResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcDownloadFile struct {
}

func (m *RpcDownloadFile) Reset()         { *m = RpcDownloadFile{} }
func (m *RpcDownloadFile) String() string { return proto.CompactTextString(m) }
func (*RpcDownloadFile) ProtoMessage()    {}
func (*RpcDownloadFile) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17}
}
func (m *RpcDownloadFile) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDownloadFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDownloadFile.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDownloadFile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDownloadFile.Merge(m, src)
}
func (m *RpcDownloadFile) XXX_Size() int {
	return m.Size()
}
func (m *RpcDownloadFile) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDownloadFile.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDownloadFile proto.InternalMessageInfo

type RpcDownloadFileRequest struct {
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
}

func (m *RpcDownloadFileRequest) Reset()         { *m = RpcDownloadFileRequest{} }
func (m *RpcDownloadFileRequest) String() string { return proto.CompactTextString(m) }
func (*RpcDownloadFileRequest) ProtoMessage()    {}
func (*RpcDownloadFileRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 0}
}
func (m *RpcDownloadFileRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDownloadFileRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDownloadFileRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDownloadFileRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDownloadFileRequest.Merge(m, src)
}
func (m *RpcDownloadFileRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcDownloadFileRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDownloadFileRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDownloadFileRequest proto.InternalMessageInfo

func (m *RpcDownloadFileRequest) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *RpcDownloadFileRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type RpcDownloadFileResponse struct {
	Error     *RpcDownloadFileResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LocalPath string                        `protobuf:"bytes,2,opt,name=localPath,proto3" json:"localPath,omitempty"`
}

func (m *RpcDownloadFileResponse) Reset()         { *m = RpcDownloadFileResponse{} }
func (m *RpcDownloadFileResponse) String() string { return proto.CompactTextString(m) }
func (*RpcDownloadFileResponse) ProtoMessage()    {}
func (*RpcDownloadFileResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1}
}
func (m *RpcDownloadFileResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDownloadFileResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDownloadFileResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDownloadFileResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDownloadFileResponse.Merge(m, src)
}
func (m *RpcDownloadFileResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcDownloadFileResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDownloadFileResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDownloadFileResponse proto.InternalMessageInfo

func (m *RpcDownloadFileResponse) GetError() *RpcDownloadFileResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcDownloadFileResponse) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

type RpcDownloadFileResponseError struct {
	Code        RpcDownloadFileResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcDownloadFileResponseErrorCode" json:"code,omitempty"`
	Description string                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcDownloadFileResponseError) Reset()         { *m = RpcDownloadFileResponseError{} }
func (m *RpcDownloadFileResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcDownloadFileResponseError) ProtoMessage()    {}
func (*RpcDownloadFileResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1, 0}
}
func (m *RpcDownloadFileResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDownloadFileResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDownloadFileResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDownloadFileResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDownloadFileResponseError.Merge(m, src)
}
func (m *RpcDownloadFileResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcDownloadFileResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDownloadFileResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDownloadFileResponseError proto.InternalMessageInfo

func (m *RpcDownloadFileResponseError) GetCode() RpcDownloadFileResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcDownloadFileResponseError_NULL
}

func (m *RpcDownloadFileResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcNavigation struct {
}

func (m *RpcNavigation) Reset()         { *m = RpcNavigation{} }
func (m *RpcNavigation) String() string { return proto.CompactTextString(m) }
func (*RpcNavigation) ProtoMessage()    {}
func (*RpcNavigation) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18}
}
func (m *RpcNavigation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigation.Merge(m, src)
}
func (m *RpcNavigation) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigation) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigation.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigation proto.InternalMessageInfo

type RpcNavigationListObjects struct {
}

func (m *RpcNavigationListObjects) Reset()         { *m = RpcNavigationListObjects{} }
func (m *RpcNavigationListObjects) String() string { return proto.CompactTextString(m) }
func (*RpcNavigationListObjects) ProtoMessage()    {}
func (*RpcNavigationListObjects) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0}
}
func (m *RpcNavigationListObjects) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationListObjects) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationListObjects.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationListObjects) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationListObjects.Merge(m, src)
}
func (m *RpcNavigationListObjects) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationListObjects) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationListObjects.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationListObjects proto.InternalMessageInfo

type RpcNavigationListObjectsRequest struct {
	Context  RpcNavigationContext `protobuf:"varint,1,opt,name=context,proto3,enum=anytype.RpcNavigationContext" json:"context,omitempty"`
	FullText string               `protobuf:"bytes,2,opt,name=fullText,proto3" json:"fullText,omitempty"`
	Limit    int32                `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset   int32                `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
}

func (m *RpcNavigationListObjectsRequest) Reset()         { *m = RpcNavigationListObjectsRequest{} }
func (m *RpcNavigationListObjectsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcNavigationListObjectsRequest) ProtoMessage()    {}
func (*RpcNavigationListObjectsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 0}
}
func (m *RpcNavigationListObjectsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationListObjectsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationListObjectsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationListObjectsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationListObjectsRequest.Merge(m, src)
}
func (m *RpcNavigationListObjectsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationListObjectsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationListObjectsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationListObjectsRequest proto.InternalMessageInfo

func (m *RpcNavigationListObjectsRequest) GetContext() RpcNavigationContext {
	if m != nil {
		return m.Context
	}
	return RpcNavigation_Navigation
}

func (m *RpcNavigationListObjectsRequest) GetFullText() string {
	if m != nil {
		return m.FullText
	}
	return ""
}

func (m *RpcNavigationListObjectsRequest) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RpcNavigationListObjectsRequest) GetOffset() int32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type RpcNavigationListObjectsResponse struct {
	Error   *RpcNavigationListObjectsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Objects []*model.ObjectInfo                    `protobuf:"bytes,2,rep,name=objects,proto3" json:"objects,omitempty"`
}

func (m *RpcNavigationListObjectsResponse) Reset()         { *m = RpcNavigationListObjectsResponse{} }
func (m *RpcNavigationListObjectsResponse) String() string { return proto.CompactTextString(m) }
func (*RpcNavigationListObjectsResponse) ProtoMessage()    {}
func (*RpcNavigationListObjectsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 1}
}
func (m *RpcNavigationListObjectsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationListObjectsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationListObjectsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationListObjectsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationListObjectsResponse.Merge(m, src)
}
func (m *RpcNavigationListObjectsResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationListObjectsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationListObjectsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationListObjectsResponse proto.InternalMessageInfo

func (m *RpcNavigationListObjectsResponse) GetError() *RpcNavigationListObjectsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcNavigationListObjectsResponse) GetObjects() []*model.ObjectInfo {
	if m != nil {
		return m.Objects
	}
	return nil
}

type RpcNavigationListObjectsResponseError struct {
	Code        RpcNavigationListObjectsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcNavigationListObjectsResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcNavigationListObjectsResponseError) Reset()         { *m = RpcNavigationListObjectsResponseError{} }
func (m *RpcNavigationListObjectsResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcNavigationListObjectsResponseError) ProtoMessage()    {}
func (*RpcNavigationListObjectsResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 1, 0}
}
func (m *RpcNavigationListObjectsResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationListObjectsResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationListObjectsResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationListObjectsResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationListObjectsResponseError.Merge(m, src)
}
func (m *RpcNavigationListObjectsResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationListObjectsResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationListObjectsResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationListObjectsResponseError proto.InternalMessageInfo

func (m *RpcNavigationListObjectsResponseError) GetCode() RpcNavigationListObjectsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcNavigationListObjectsResponseError_NULL
}

func (m *RpcNavigationListObjectsResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

//
// Get the info for page alongside with info for all inbound and outbound links from/to this page
type RpcNavigationGetObjectInfoWithLinks struct {
}

func (m *RpcNavigationGetObjectInfoWithLinks) Reset()         { *m = RpcNavigationGetObjectInfoWithLinks{} }
func (m *RpcNavigationGetObjectInfoWithLinks) String() string { return proto.CompactTextString(m) }
func (*RpcNavigationGetObjectInfoWithLinks) ProtoMessage()    {}
func (*RpcNavigationGetObjectInfoWithLinks) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 1}
}
func (m *RpcNavigationGetObjectInfoWithLinks) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationGetObjectInfoWithLinks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationGetObjectInfoWithLinks.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationGetObjectInfoWithLinks) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinks.Merge(m, src)
}
func (m *RpcNavigationGetObjectInfoWithLinks) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationGetObjectInfoWithLinks) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinks.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationGetObjectInfoWithLinks proto.InternalMessageInfo

type RpcNavigationGetObjectInfoWithLinksRequest struct {
	ObjectId string               `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Context  RpcNavigationContext `protobuf:"varint,2,opt,name=context,proto3,enum=anytype.RpcNavigationContext" json:"context,omitempty"`
}

func (m *RpcNavigationGetObjectInfoWithLinksRequest) Reset() {
	*m = RpcNavigationGetObjectInfoWithLinksRequest{}
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) String() string {
	return proto.CompactTextString(m)
}
func (*RpcNavigationGetObjectInfoWithLinksRequest) ProtoMessage() {}
func (*RpcNavigationGetObjectInfoWithLinksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 1, 0}
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksRequest.Merge(m, src)
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksRequest proto.InternalMessageInfo

func (m *RpcNavigationGetObjectInfoWithLinksRequest) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	return ""
}

func (m *RpcNavigationGetObjectInfoWithLinksRequest) GetContext() RpcNavigationContext {
	if m != nil {
		return m.Context
	}
	return RpcNavigation_Navigation
}

type RpcNavigationGetObjectInfoWithLinksResponse struct {
	Error  *RpcNavigationGetObjectInfoWithLinksResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Object *model.ObjectInfoWithLinks                        `protobuf:"bytes,2,opt,name=object,proto3" json:"object,omitempty"`
}

func (m *RpcNavigationGetObjectInfoWithLinksResponse) Reset() {
	*m = RpcNavigationGetObjectInfoWithLinksResponse{}
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) String() string {
	return proto.CompactTextString(m)
}
func (*RpcNavigationGetObjectInfoWithLinksResponse) ProtoMessage() {}
func (*RpcNavigationGetObjectInfoWithLinksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 1, 1}
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponse.Merge(m, src)
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponse proto.InternalMessageInfo

func (m *RpcNavigationGetObjectInfoWithLinksResponse) GetError() *RpcNavigationGetObjectInfoWithLinksResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcNavigationGetObjectInfoWithLinksResponse) GetObject() *model.ObjectInfoWithLinks {
	if m != nil {
		return m.Object
	}
	return nil
}

type RpcNavigationGetObjectInfoWithLinksResponseError struct {
	Code        RpcNavigationGetObjectInfoWithLinksResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcNavigationGetObjectInfoWithLinksResponseErrorCode" json:"code,omitempty"`
	Description string                                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) Reset() {
	*m = RpcNavigationGetObjectInfoWithLinksResponseError{}
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcNavigationGetObjectInfoWithLinksResponseError) ProtoMessage() {}
func (*RpcNavigationGetObjectInfoWithLinksResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 1, 1, 0}
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponseError.Merge(m, src)
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcNavigationGetObjectInfoWithLinksResponseError proto.InternalMessageInfo

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) GetCode() RpcNavigationGetObjectInfoWithLinksResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcNavigationGetObjectInfoWithLinksResponseError_NULL
}

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcHistory struct {
}

func (m *RpcHistory) Reset()         { *m = RpcHistory{} }
func (m *RpcHistory) String() string { return proto.CompactTextString(m) }
func (*RpcHistory) ProtoMessage()    {}
func (*RpcHistory) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19}
}
func (m *RpcHistory) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistory.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistory) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistory.Merge(m, src)
}
func (m *RpcHistory) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistory) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistory.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistory proto.InternalMessageInfo

// returns list of versions (changes)
type RpcHistoryVersions struct {
}

func (m *RpcHistoryVersions) Reset()         { *m = RpcHistoryVersions{} }
func (m *RpcHistoryVersions) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryVersions) ProtoMessage()    {}
func (*RpcHistoryVersions) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0}
}
func (m *RpcHistoryVersions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryVersions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryVersions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryVersions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryVersions.Merge(m, src)
}
func (m *RpcHistoryVersions) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryVersions) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryVersions.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryVersions proto.InternalMessageInfo

type RpcHistoryVersionsVersion struct {
	Id          string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	PreviousIds []string `protobuf:"bytes,2,rep,name=previousIds,proto3" json:"previousIds,omitempty"`
	AuthorId    string   `protobuf:"bytes,3,opt,name=authorId,proto3" json:"authorId,omitempty"`
	AuthorName  string   `protobuf:"bytes,4,opt,name=authorName,proto3" json:"authorName,omitempty"`
	Time        int64    `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
	GroupId     int64    `protobuf:"varint,6,opt,name=groupId,proto3" json:"groupId,omitempty"`
}

func (m *RpcHistoryVersionsVersion) Reset()         { *m = RpcHistoryVersionsVersion{} }
func (m *RpcHistoryVersionsVersion) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryVersionsVersion) ProtoMessage()    {}
func (*RpcHistoryVersionsVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 0}
}
func (m *RpcHistoryVersionsVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryVersionsVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryVersionsVersion.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryVersionsVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryVersionsVersion.Merge(m, src)
}
func (m *RpcHistoryVersionsVersion) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryVersionsVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryVersionsVersion.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryVersionsVersion proto.InternalMessageInfo

func (m *RpcHistoryVersionsVersion) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcHistoryVersionsVersion) GetPreviousIds() []string {
	if m != nil {
		return m.PreviousIds
	}
	return nil
}

func (m *RpcHistoryVersionsVersion) GetAuthorId() string {
	if m != nil {
		return m.AuthorId
	}
	return ""
}

func (m *RpcHistoryVersionsVersion) GetAuthorName() string {
	if m != nil {
		return m.AuthorName
	}
	return ""
}

func (m *RpcHistoryVersionsVersion) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *RpcHistoryVersionsVersion) GetGroupId() int64 {
	if m != nil {
		return m.GroupId
	}
	return 0
}

type RpcHistoryVersionsRequest struct {
	PageId string `protobuf:"bytes,1,opt,name=pageId,proto3" json:"pageId,omitempty"`
	// when indicated, results will include versions before given id
	LastVersionId string `protobuf:"bytes,2,opt,name=lastVersionId,proto3" json:"lastVersionId,omitempty"`
	// desired count of versions
	Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
}

func (m *RpcHistoryVersionsRequest) Reset()         { *m = RpcHistoryVersionsRequest{} }
func (m *RpcHistoryVersionsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryVersionsRequest) ProtoMessage()    {}
func (*RpcHistoryVersionsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 1}
}
func (m *RpcHistoryVersionsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryVersionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryVersionsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryVersionsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryVersionsRequest.Merge(m, src)
}
func (m *RpcHistoryVersionsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryVersionsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryVersionsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryVersionsRequest proto.InternalMessageInfo

func (m *RpcHistoryVersionsRequest) GetPageId() string {
	if m != nil {
		return m.PageId
	}
	return ""
}

func (m *RpcHistoryVersionsRequest) GetLastVersionId() string {
	if m != nil {
		return m.LastVersionId
	}
	return ""
}

func (m *RpcHistoryVersionsRequest) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

type RpcHistoryVersionsResponse struct {
	Error    *RpcHistoryVersionsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Versions []*RpcHistoryVersionsVersion     `protobuf:"bytes,2,rep,name=versions,proto3" json:"versions,omitempty"`
}

func (m *RpcHistoryVersionsResponse) Reset()         { *m = RpcHistoryVersionsResponse{} }
func (m *RpcHistoryVersionsResponse) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryVersionsResponse) ProtoMessage()    {}
func (*RpcHistoryVersionsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 2}
}
func (m *RpcHistoryVersionsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryVersionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryVersionsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryVersionsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryVersionsResponse.Merge(m, src)
}
func (m *RpcHistoryVersionsResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryVersionsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryVersionsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryVersionsResponse proto.InternalMessageInfo

func (m *RpcHistoryVersionsResponse) GetError() *RpcHistoryVersionsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcHistoryVersionsResponse) GetVersions() []*RpcHistoryVersionsVersion {
	if m != nil {
		return m.Versions
	}
	return nil
}

type RpcHistoryVersionsResponseError struct {
	Code        RpcHistoryVersionsResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcHistoryVersionsResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcHistoryVersionsResponseError) Reset()         { *m = RpcHistoryVersionsResponseError{} }
func (m *RpcHistoryVersionsResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryVersionsResponseError) ProtoMessage()    {}
func (*RpcHistoryVersionsResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 2, 0}
}
func (m *RpcHistoryVersionsResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryVersionsResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryVersionsResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryVersionsResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryVersionsResponseError.Merge(m, src)
}
func (m *RpcHistoryVersionsResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryVersionsResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryVersionsResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryVersionsResponseError proto.InternalMessageInfo

func (m *RpcHistoryVersionsResponseError) GetCode() RpcHistoryVersionsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcHistoryVersionsResponseError_NULL
}

func (m *RpcHistoryVersionsResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

// returns blockShow event for given version
type RpcHistoryShow struct {
}

func (m *RpcHistoryShow) Reset()         { *m = RpcHistoryShow{} }
func (m *RpcHistoryShow) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryShow) ProtoMessage()    {}
func (*RpcHistoryShow) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1}
}
func (m *RpcHistoryShow) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryShow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryShow.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryShow) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryShow.Merge(m, src)
}
func (m *RpcHistoryShow) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryShow) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryShow.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryShow proto.InternalMessageInfo

type RpcHistoryShowRequest struct {
	PageId    string `protobuf:"bytes,1,opt,name=pageId,proto3" json:"pageId,omitempty"`
	VersionId string `protobuf:"bytes,2,opt,name=versionId,proto3" json:"versionId,omitempty"`
	TraceId   string `protobuf:"bytes,3,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

func (m *RpcHistoryShowRequest) Reset()         { *m = RpcHistoryShowRequest{} }
func (m *RpcHistoryShowRequest) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryShowRequest) ProtoMessage()    {}
func (*RpcHistoryShowRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 0}
}
func (m *RpcHistoryShowRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryShowRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryShowRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryShowRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryShowRequest.Merge(m, src)
}
func (m *RpcHistoryShowRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryShowRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryShowRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryShowRequest proto.InternalMessageInfo

func (m *RpcHistoryShowRequest) GetPageId() string {
	if m != nil {
		return m.PageId
	}
	return ""
}

func (m *RpcHistoryShowRequest) GetVersionId() string {
	if m != nil {
		return m.VersionId
	}
	return ""
}

func (m *RpcHistoryShowRequest) GetTraceId() string {
	if m != nil {
		return m.TraceId
	}
	return ""
}

type RpcHistoryShowResponse struct {
	Error      *RpcHistoryShowResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectShow *EventObjectShow             `protobuf:"bytes,2,opt,name=objectShow,proto3" json:"objectShow,omitempty"`
	Version    *RpcHistoryVersionsVersion   `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	TraceId    string                       `protobuf:"bytes,4,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

func (m *RpcHistoryShowResponse) Reset()         { *m = RpcHistoryShowResponse{} }
func (m *RpcHistoryShowResponse) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryShowResponse) ProtoMessage()    {}
func (*RpcHistoryShowResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 1}
}
func (m *RpcHistoryShowResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryShowResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryShowResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryShowResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryShowResponse.Merge(m, src)
}
func (m *RpcHistoryShowResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryShowResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryShowResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryShowResponse proto.InternalMessageInfo

func (m *RpcHistoryShowResponse) GetError() *RpcHistoryShowResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcHistoryShowResponse) GetObjectShow() *EventObjectShow {
	if m != nil {
		return m.ObjectShow
	}
	return nil
}

func (m *RpcHistoryShowResponse) GetVersion() *RpcHistoryVersionsVersion {
	if m != nil {
		return m.Version
	}
	return nil
}

func (m *RpcHistoryShowResponse) GetTraceId() string {
	if m != nil {
		return m.TraceId
	}
	return ""
}

type RpcHistoryShowResponseError struct {
	Code        RpcHistoryShowResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcHistoryShowResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcHistoryShowResponseError) Reset()         { *m = RpcHistoryShowResponseError{} }
func (m *RpcHistoryShowResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryShowResponseError) ProtoMessage()    {}
func (*RpcHistoryShowResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 1, 0}
}
func (m *RpcHistoryShowResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryShowResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryShowResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryShowResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryShowResponseError.Merge(m, src)
}
func (m *RpcHistoryShowResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryShowResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryShowResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryShowResponseError proto.InternalMessageInfo

func (m *RpcHistoryShowResponseError) GetCode() RpcHistoryShowResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcHistoryShowResponseError_NULL
}

func (m *RpcHistoryShowResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcHistorySetVersion struct {
}

func (m *RpcHistorySetVersion) Reset()         { *m = RpcHistorySetVersion{} }
func (m *RpcHistorySetVersion) String() string { return proto.CompactTextString(m) }
func (*RpcHistorySetVersion) ProtoMessage()    {}
func (*RpcHistorySetVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 2}
}
func (m *RpcHistorySetVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistorySetVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistorySetVersion.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistorySetVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistorySetVersion.Merge(m, src)
}
func (m *RpcHistorySetVersion) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistorySetVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistorySetVersion.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistorySetVersion proto.InternalMessageInfo

type RpcHistorySetVersionRequest struct {
	PageId    string `protobuf:"bytes,1,opt,name=pageId,proto3" json:"pageId,omitempty"`
	VersionId string `protobuf:"bytes,2,opt,name=versionId,proto3" json:"versionId,omitempty"`
}

func (m *RpcHistorySetVersionRequest) Reset()         { *m = RpcHistorySetVersionRequest{} }
func (m *RpcHistorySetVersionRequest) String() string { return proto.CompactTextString(m) }
func (*RpcHistorySetVersionRequest) ProtoMessage()    {}
func (*RpcHistorySetVersionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 2, 0}
}
func (m *RpcHistorySetVersionRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistorySetVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistorySetVersionRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistorySetVersionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistorySetVersionRequest.Merge(m, src)
}
func (m *RpcHistorySetVersionRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistorySetVersionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistorySetVersionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistorySetVersionRequest proto.InternalMessageInfo

func (m *RpcHistorySetVersionRequest) GetPageId() string {
	if m != nil {
		return m.PageId
	}
	return ""
}

func (m *RpcHistorySetVersionRequest) GetVersionId() string {
	if m != nil {
		return m.VersionId
	}
	return ""
}

type RpcHistorySetVersionResponse struct {
	Error *RpcHistorySetVersionResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcHistorySetVersionResponse) Reset()         { *m = RpcHistorySetVersionResponse{} }
func (m *RpcHistorySetVersionResponse) String() string { return proto.CompactTextString(m) }
func (*RpcHistorySetVersionResponse) ProtoMessage()    {}
func (*RpcHistorySetVersionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 2, 1}
}
func (m *RpcHistorySetVersionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistorySetVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistorySetVersionResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistorySetVersionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistorySetVersionResponse.Merge(m, src)
}
func (m *RpcHistorySetVersionResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistorySetVersionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistorySetVersionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistorySetVersionResponse proto.InternalMessageInfo

func (m *RpcHistorySetVersionResponse) GetError() *RpcHistorySetVersionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcHistorySetVersionResponseError struct {
	Code        RpcHistorySetVersionResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcHistorySetVersionResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcHistorySetVersionResponseError) Reset()         { *m = RpcHistorySetVersionResponseError{} }
func (m *RpcHistorySetVersionResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcHistorySetVersionResponseError) ProtoMessage()    {}
func (*RpcHistorySetVersionResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 2, 1, 0}
}
func (m *RpcHistorySetVersionResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistorySetVersionResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistorySetVersionResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistorySetVersionResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistorySetVersionResponseError.Merge(m, src)
}
func (m *RpcHistorySetVersionResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistorySetVersionResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistorySetVersionResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistorySetVersionResponseError proto.InternalMessageInfo

func (m *RpcHistorySetVersionResponseError) GetCode() RpcHistorySetVersionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcHistorySetVersionResponseError_NULL
}

func (m *RpcHistorySetVersionResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcPage struct {
}

func (m *RpcPage) Reset()         { *m = RpcPage{} }
func (m *RpcPage) String() string { return proto.CompactTextString(m) }
func (*RpcPage) ProtoMessage()    {}
func (*RpcPage) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20}
}
func (m *RpcPage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPage.Merge(m, src)
}
func (m *RpcPage) XXX_Size() int {
	return m.Size()
}
func (m *RpcPage) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPage.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPage proto.InternalMessageInfo

type RpcPageCreate struct {
}

func (m *RpcPageCreate) Reset()         { *m = RpcPageCreate{} }
func (m *RpcPageCreate) String() string { return proto.CompactTextString(m) }
func (*RpcPageCreate) ProtoMessage()    {}
func (*RpcPageCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0}
}
func (m *RpcPageCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPageCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPageCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPageCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPageCreate.Merge(m, src)
}
func (m *RpcPageCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcPageCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPageCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPageCreate proto.InternalMessageInfo

type RpcPageCreateRequest struct {
	Details *types.Struct `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
}

func (m *RpcPageCreateRequest) Reset()         { *m = RpcPageCreateRequest{} }
func (m *RpcPageCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcPageCreateRequest) ProtoMessage()    {}
func (*RpcPageCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 0}
}
func (m *RpcPageCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPageCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPageCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPageCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPageCreateRequest.Merge(m, src)
}
func (m *RpcPageCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcPageCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPageCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPageCreateRequest proto.InternalMessageInfo

func (m *RpcPageCreateRequest) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

type RpcPageCreateResponse struct {
	Error  *RpcPageCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	PageId string                      `protobuf:"bytes,3,opt,name=pageId,proto3" json:"pageId,omitempty"`
	Event  *ResponseEvent              `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcPageCreateResponse) Reset()         { *m = RpcPageCreateResponse{} }
func (m *RpcPageCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcPageCreateResponse) ProtoMessage()    {}
func (*RpcPageCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 1}
}
func (m *RpcPageCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPageCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPageCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPageCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPageCreateResponse.Merge(m, src)
}
func (m *RpcPageCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcPageCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPageCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPageCreateResponse proto.InternalMessageInfo

func (m *RpcPageCreateResponse) GetError() *RpcPageCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcPageCreateResponse) GetPageId() string {
	if m != nil {
		return m.PageId
	}
	return ""
}

func (m *RpcPageCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcPageCreateResponseError struct {
	Code        RpcPageCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcPageCreateResponseErrorCode" json:"code,omitempty"`
	Description string                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcPageCreateResponseError) Reset()         { *m = RpcPageCreateResponseError{} }
func (m *RpcPageCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcPageCreateResponseError) ProtoMessage()    {}
func (*RpcPageCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 1, 0}
}
func (m *RpcPageCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcPageCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcPageCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcPageCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcPageCreateResponseError.Merge(m, src)
}
func (m *RpcPageCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcPageCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcPageCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcPageCreateResponseError proto.InternalMessageInfo

func (m *RpcPageCreateResponseError) GetCode() RpcPageCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcPageCreateResponseError_NULL
}

func (m *RpcPageCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcSet struct {
}

func (m *RpcSet) Reset()         { *m = RpcSet{} }
func (m *RpcSet) String() string { return proto.CompactTextString(m) }
func (*RpcSet) ProtoMessage()    {}
func (*RpcSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21}
}
func (m *RpcSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcSet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcSet.Merge(m, src)
}
func (m *RpcSet) XXX_Size() int {
	return m.Size()
}
func (m *RpcSet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcSet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcSet proto.InternalMessageInfo

type RpcSetCreate struct {
}

func (m *RpcSetCreate) Reset()         { *m = RpcSetCreate{} }
func (m *RpcSetCreate) String() string { return proto.CompactTextString(m) }
func (*RpcSetCreate) ProtoMessage()    {}
func (*RpcSetCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0}
}
func (m *RpcSetCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcSetCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcSetCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcSetCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcSetCreate.Merge(m, src)
}
func (m *RpcSetCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcSetCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcSetCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcSetCreate proto.InternalMessageInfo

type RpcSetCreateRequest struct {
	Source     []string      `protobuf:"bytes,1,rep,name=source,proto3" json:"source,omitempty"`
	Details    *types.Struct `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	TemplateId string        `protobuf:"bytes,3,opt,name=templateId,proto3" json:"templateId,omitempty"`
}

func (m *RpcSetCreateRequest) Reset()         { *m = RpcSetCreateRequest{} }
func (m *RpcSetCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcSetCreateRequest) ProtoMessage()    {}
func (*RpcSetCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 0}
}
func (m *RpcSetCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcSetCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcSetCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcSetCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcSetCreateRequest.Merge(m, src)
}
func (m *RpcSetCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcSetCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcSetCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcSetCreateRequest proto.InternalMessageInfo

func (m *RpcSetCreateRequest) GetSource() []string {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *RpcSetCreateRequest) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *RpcSetCreateRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

type RpcSetCreateResponse struct {
	Error *RpcSetCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Id    string                     `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	Event *ResponseEvent             `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcSetCreateResponse) Reset()         { *m = RpcSetCreateResponse{} }
func (m *RpcSetCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcSetCreateResponse) ProtoMessage()    {}
func (*RpcSetCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 1}
}
func (m *RpcSetCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcSetCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcSetCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcSetCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcSetCreateResponse.Merge(m, src)
}
func (m *RpcSetCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcSetCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcSetCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcSetCreateResponse proto.InternalMessageInfo

func (m *RpcSetCreateResponse) GetError() *RpcSetCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcSetCreateResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcSetCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcSetCreateResponseError struct {
	Code        RpcSetCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcSetCreateResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcSetCreateResponseError) Reset()         { *m = RpcSetCreateResponseError{} }
func (m *RpcSetCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcSetCreateResponseError) ProtoMessage()    {}
func (*RpcSetCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 1, 0}
}
func (m *RpcSetCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcSetCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcSetCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcSetCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcSetCreateResponseError.Merge(m, src)
}
func (m *RpcSetCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcSetCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcSetCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcSetCreateResponseError proto.InternalMessageInfo

func (m *RpcSetCreateResponseError) GetCode() RpcSetCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcSetCreateResponseError_NULL
}

func (m *RpcSetCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectType struct {
}

func (m *RpcObjectType) Reset()         { *m = RpcObjectType{} }
func (m *RpcObjectType) String() string { return proto.CompactTextString(m) }
func (*RpcObjectType) ProtoMessage()    {}
func (*RpcObjectType) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22}
}
func (m *RpcObjectType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectType.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectType.Merge(m, src)
}
func (m *RpcObjectType) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectType) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectType.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectType proto.InternalMessageInfo

type RpcObjectTypeList struct {
}

func (m *RpcObjectTypeList) Reset()         { *m = RpcObjectTypeList{} }
func (m *RpcObjectTypeList) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeList) ProtoMessage()    {}
func (*RpcObjectTypeList) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 0}
}
func (m *RpcObjectTypeList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeList.Merge(m, src)
}
func (m *RpcObjectTypeList) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeList) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeList.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeList proto.InternalMessageInfo

type RpcObjectTypeListRequest struct {
}

func (m *RpcObjectTypeListRequest) Reset()         { *m = RpcObjectTypeListRequest{} }
func (m *RpcObjectTypeListRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeListRequest) ProtoMessage()    {}
func (*RpcObjectTypeListRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 0, 0}
}
func (m *RpcObjectTypeListRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeListRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeListRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeListRequest.Merge(m, src)
}
func (m *RpcObjectTypeListRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeListRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeListRequest proto.InternalMessageInfo

type RpcObjectTypeListResponse struct {
	Error       *RpcObjectTypeListResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectTypes []*model.ObjectType             `protobuf:"bytes,2,rep,name=objectTypes,proto3" json:"objectTypes,omitempty"`
}

func (m *RpcObjectTypeListResponse) Reset()         { *m = RpcObjectTypeListResponse{} }
func (m *RpcObjectTypeListResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeListResponse) ProtoMessage()    {}
func (*RpcObjectTypeListResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 0, 1}
}
func (m *RpcObjectTypeListResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeListResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeListResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeListResponse.Merge(m, src)
}
func (m *RpcObjectTypeListResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeListResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeListResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeListResponse proto.InternalMessageInfo

func (m *RpcObjectTypeListResponse) GetError() *RpcObjectTypeListResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectTypeListResponse) GetObjectTypes() []*model.ObjectType {
	if m != nil {
		return m.ObjectTypes
	}
	return nil
}

type RpcObjectTypeListResponseError struct {
	Code        RpcObjectTypeListResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectTypeListResponseErrorCode" json:"code,omitempty"`
	Description string                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectTypeListResponseError) Reset()         { *m = RpcObjectTypeListResponseError{} }
func (m *RpcObjectTypeListResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeListResponseError) ProtoMessage()    {}
func (*RpcObjectTypeListResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 0, 1, 0}
}
func (m *RpcObjectTypeListResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeListResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeListResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeListResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeListResponseError.Merge(m, src)
}
func (m *RpcObjectTypeListResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeListResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeListResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeListResponseError proto.InternalMessageInfo

func (m *RpcObjectTypeListResponseError) GetCode() RpcObjectTypeListResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectTypeListResponseError_NULL
}

func (m *RpcObjectTypeListResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectTypeCreate struct {
}

func (m *RpcObjectTypeCreate) Reset()         { *m = RpcObjectTypeCreate{} }
func (m *RpcObjectTypeCreate) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeCreate) ProtoMessage()    {}
func (*RpcObjectTypeCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 1}
}
func (m *RpcObjectTypeCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeCreate.Merge(m, src)
}
func (m *RpcObjectTypeCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeCreate proto.InternalMessageInfo

type RpcObjectTypeCreateRequest struct {
	ObjectType *model.ObjectType `protobuf:"bytes,1,opt,name=objectType,proto3" json:"objectType,omitempty"`
}

func (m *RpcObjectTypeCreateRequest) Reset()         { *m = RpcObjectTypeCreateRequest{} }
func (m *RpcObjectTypeCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeCreateRequest) ProtoMessage()    {}
func (*RpcObjectTypeCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 1, 0}
}
func (m *RpcObjectTypeCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeCreateRequest.Merge(m, src)
}
func (m *RpcObjectTypeCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeCreateRequest proto.InternalMessageInfo

func (m *RpcObjectTypeCreateRequest) GetObjectType() *model.ObjectType {
	if m != nil {
		return m.ObjectType
	}
	return nil
}

type RpcObjectTypeCreateResponse struct {
	Error      *RpcObjectTypeCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectType *model.ObjectType                 `protobuf:"bytes,2,opt,name=objectType,proto3" json:"objectType,omitempty"`
}

func (m *RpcObjectTypeCreateResponse) Reset()         { *m = RpcObjectTypeCreateResponse{} }
func (m *RpcObjectTypeCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeCreateResponse) ProtoMessage()    {}
func (*RpcObjectTypeCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 1, 1}
}
func (m *RpcObjectTypeCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeCreateResponse.Merge(m, src)
}
func (m *RpcObjectTypeCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeCreateResponse proto.InternalMessageInfo

func (m *RpcObjectTypeCreateResponse) GetError() *RpcObjectTypeCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectTypeCreateResponse) GetObjectType() *model.ObjectType {
	if m != nil {
		return m.ObjectType
	}
	return nil
}

type RpcObjectTypeCreateResponseError struct {
	Code        RpcObjectTypeCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectTypeCreateResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectTypeCreateResponseError) Reset()         { *m = RpcObjectTypeCreateResponseError{} }
func (m *RpcObjectTypeCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeCreateResponseError) ProtoMessage()    {}
func (*RpcObjectTypeCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 1, 1, 0}
}
func (m *RpcObjectTypeCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeCreateResponseError.Merge(m, src)
}
func (m *RpcObjectTypeCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeCreateResponseError proto.InternalMessageInfo

func (m *RpcObjectTypeCreateResponseError) GetCode() RpcObjectTypeCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectTypeCreateResponseError_NULL
}

func (m *RpcObjectTypeCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectTypeRelation struct {
}

func (m *RpcObjectTypeRelation) Reset()         { *m = RpcObjectTypeRelation{} }
func (m *RpcObjectTypeRelation) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelation) ProtoMessage()    {}
func (*RpcObjectTypeRelation) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2}
}
func (m *RpcObjectTypeRelation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelation.Merge(m, src)
}
func (m *RpcObjectTypeRelation) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelation) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelation.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelation proto.InternalMessageInfo

type RpcObjectTypeRelationAdd struct {
}

func (m *RpcObjectTypeRelationAdd) Reset()         { *m = RpcObjectTypeRelationAdd{} }
func (m *RpcObjectTypeRelationAdd) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationAdd) ProtoMessage()    {}
func (*RpcObjectTypeRelationAdd) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 0}
}
func (m *RpcObjectTypeRelationAdd) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationAdd.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationAdd) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationAdd.Merge(m, src)
}
func (m *RpcObjectTypeRelationAdd) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationAdd) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationAdd.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationAdd proto.InternalMessageInfo

type RpcObjectTypeRelationAddRequest struct {
	ObjectTypeUrl string            `protobuf:"bytes,1,opt,name=objectTypeUrl,proto3" json:"objectTypeUrl,omitempty"`
	Relations     []*model.Relation `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcObjectTypeRelationAddRequest) Reset()         { *m = RpcObjectTypeRelationAddRequest{} }
func (m *RpcObjectTypeRelationAddRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationAddRequest) ProtoMessage()    {}
func (*RpcObjectTypeRelationAddRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 0, 0}
}
func (m *RpcObjectTypeRelationAddRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationAddRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationAddRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationAddRequest.Merge(m, src)
}
func (m *RpcObjectTypeRelationAddRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationAddRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationAddRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationAddRequest proto.InternalMessageInfo

func (m *RpcObjectTypeRelationAddRequest) GetObjectTypeUrl() string {
	if m != nil {
		return m.ObjectTypeUrl
	}
	return ""
}

func (m *RpcObjectTypeRelationAddRequest) GetRelations() []*model.Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcObjectTypeRelationAddResponse struct {
	Error     *RpcObjectTypeRelationAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Relations []*model.Relation                      `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcObjectTypeRelationAddResponse) Reset()         { *m = RpcObjectTypeRelationAddResponse{} }
func (m *RpcObjectTypeRelationAddResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationAddResponse) ProtoMessage()    {}
func (*RpcObjectTypeRelationAddResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 0, 1}
}
func (m *RpcObjectTypeRelationAddResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationAddResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationAddResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationAddResponse.Merge(m, src)
}
func (m *RpcObjectTypeRelationAddResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationAddResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationAddResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationAddResponse proto.InternalMessageInfo

func (m *RpcObjectTypeRelationAddResponse) GetError() *RpcObjectTypeRelationAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectTypeRelationAddResponse) GetRelations() []*model.Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcObjectTypeRelationAddResponseError struct {
	Code        RpcObjectTypeRelationAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectTypeRelationAddResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectTypeRelationAddResponseError) Reset()         { *m = RpcObjectTypeRelationAddResponseError{} }
func (m *RpcObjectTypeRelationAddResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationAddResponseError) ProtoMessage()    {}
func (*RpcObjectTypeRelationAddResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 0, 1, 0}
}
func (m *RpcObjectTypeRelationAddResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationAddResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationAddResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationAddResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationAddResponseError.Merge(m, src)
}
func (m *RpcObjectTypeRelationAddResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationAddResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationAddResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationAddResponseError proto.InternalMessageInfo

func (m *RpcObjectTypeRelationAddResponseError) GetCode() RpcObjectTypeRelationAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectTypeRelationAddResponseError_NULL
}

func (m *RpcObjectTypeRelationAddResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectTypeRelationRemove struct {
}

func (m *RpcObjectTypeRelationRemove) Reset()         { *m = RpcObjectTypeRelationRemove{} }
func (m *RpcObjectTypeRelationRemove) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationRemove) ProtoMessage()    {}
func (*RpcObjectTypeRelationRemove) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 1}
}
func (m *RpcObjectTypeRelationRemove) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationRemove.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationRemove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationRemove.Merge(m, src)
}
func (m *RpcObjectTypeRelationRemove) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationRemove) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationRemove.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationRemove proto.InternalMessageInfo

type RpcObjectTypeRelationRemoveRequest struct {
	ObjectTypeUrl string `protobuf:"bytes,1,opt,name=objectTypeUrl,proto3" json:"objectTypeUrl,omitempty"`
	RelationKey   string `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
}

func (m *RpcObjectTypeRelationRemoveRequest) Reset()         { *m = RpcObjectTypeRelationRemoveRequest{} }
func (m *RpcObjectTypeRelationRemoveRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationRemoveRequest) ProtoMessage()    {}
func (*RpcObjectTypeRelationRemoveRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 1, 0}
}
func (m *RpcObjectTypeRelationRemoveRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationRemoveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationRemoveRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationRemoveRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationRemoveRequest.Merge(m, src)
}
func (m *RpcObjectTypeRelationRemoveRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationRemoveRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationRemoveRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationRemoveRequest proto.InternalMessageInfo

func (m *RpcObjectTypeRelationRemoveRequest) GetObjectTypeUrl() string {
	if m != nil {
		return m.ObjectTypeUrl
	}
	return ""
}

func (m *RpcObjectTypeRelationRemoveRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

type RpcObjectTypeRelationRemoveResponse struct {
	Error *RpcObjectTypeRelationRemoveResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectTypeRelationRemoveResponse) Reset()         { *m = RpcObjectTypeRelationRemoveResponse{} }
func (m *RpcObjectTypeRelationRemoveResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationRemoveResponse) ProtoMessage()    {}
func (*RpcObjectTypeRelationRemoveResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 1, 1}
}
func (m *RpcObjectTypeRelationRemoveResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationRemoveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationRemoveResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationRemoveResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationRemoveResponse.Merge(m, src)
}
func (m *RpcObjectTypeRelationRemoveResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationRemoveResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationRemoveResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationRemoveResponse proto.InternalMessageInfo

func (m *RpcObjectTypeRelationRemoveResponse) GetError() *RpcObjectTypeRelationRemoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectTypeRelationRemoveResponseError struct {
	Code        RpcObjectTypeRelationRemoveResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectTypeRelationRemoveResponseErrorCode" json:"code,omitempty"`
	Description string                                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectTypeRelationRemoveResponseError) Reset() {
	*m = RpcObjectTypeRelationRemoveResponseError{}
}
func (m *RpcObjectTypeRelationRemoveResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationRemoveResponseError) ProtoMessage()    {}
func (*RpcObjectTypeRelationRemoveResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 1, 1, 0}
}
func (m *RpcObjectTypeRelationRemoveResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationRemoveResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationRemoveResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationRemoveResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationRemoveResponseError.Merge(m, src)
}
func (m *RpcObjectTypeRelationRemoveResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationRemoveResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationRemoveResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationRemoveResponseError proto.InternalMessageInfo

func (m *RpcObjectTypeRelationRemoveResponseError) GetCode() RpcObjectTypeRelationRemoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectTypeRelationRemoveResponseError_NULL
}

func (m *RpcObjectTypeRelationRemoveResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectTypeRelationUpdate struct {
}

func (m *RpcObjectTypeRelationUpdate) Reset()         { *m = RpcObjectTypeRelationUpdate{} }
func (m *RpcObjectTypeRelationUpdate) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationUpdate) ProtoMessage()    {}
func (*RpcObjectTypeRelationUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 2}
}
func (m *RpcObjectTypeRelationUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationUpdate.Merge(m, src)
}
func (m *RpcObjectTypeRelationUpdate) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationUpdate proto.InternalMessageInfo

type RpcObjectTypeRelationUpdateRequest struct {
	ObjectTypeUrl string          `protobuf:"bytes,1,opt,name=objectTypeUrl,proto3" json:"objectTypeUrl,omitempty"`
	Relation      *model.Relation `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
}

func (m *RpcObjectTypeRelationUpdateRequest) Reset()         { *m = RpcObjectTypeRelationUpdateRequest{} }
func (m *RpcObjectTypeRelationUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationUpdateRequest) ProtoMessage()    {}
func (*RpcObjectTypeRelationUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 2, 0}
}
func (m *RpcObjectTypeRelationUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationUpdateRequest.Merge(m, src)
}
func (m *RpcObjectTypeRelationUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationUpdateRequest proto.InternalMessageInfo

func (m *RpcObjectTypeRelationUpdateRequest) GetObjectTypeUrl() string {
	if m != nil {
		return m.ObjectTypeUrl
	}
	return ""
}

func (m *RpcObjectTypeRelationUpdateRequest) GetRelation() *model.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

type RpcObjectTypeRelationUpdateResponse struct {
	Error *RpcObjectTypeRelationUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectTypeRelationUpdateResponse) Reset()         { *m = RpcObjectTypeRelationUpdateResponse{} }
func (m *RpcObjectTypeRelationUpdateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationUpdateResponse) ProtoMessage()    {}
func (*RpcObjectTypeRelationUpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 2, 1}
}
func (m *RpcObjectTypeRelationUpdateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationUpdateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationUpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationUpdateResponse.Merge(m, src)
}
func (m *RpcObjectTypeRelationUpdateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationUpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationUpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationUpdateResponse proto.InternalMessageInfo

func (m *RpcObjectTypeRelationUpdateResponse) GetError() *RpcObjectTypeRelationUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectTypeRelationUpdateResponseError struct {
	Code        RpcObjectTypeRelationUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectTypeRelationUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectTypeRelationUpdateResponseError) Reset() {
	*m = RpcObjectTypeRelationUpdateResponseError{}
}
func (m *RpcObjectTypeRelationUpdateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationUpdateResponseError) ProtoMessage()    {}
func (*RpcObjectTypeRelationUpdateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 2, 1, 0}
}
func (m *RpcObjectTypeRelationUpdateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationUpdateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationUpdateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationUpdateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationUpdateResponseError.Merge(m, src)
}
func (m *RpcObjectTypeRelationUpdateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationUpdateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationUpdateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationUpdateResponseError proto.InternalMessageInfo

func (m *RpcObjectTypeRelationUpdateResponseError) GetCode() RpcObjectTypeRelationUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectTypeRelationUpdateResponseError_NULL
}

func (m *RpcObjectTypeRelationUpdateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectTypeRelationList struct {
}

func (m *RpcObjectTypeRelationList) Reset()         { *m = RpcObjectTypeRelationList{} }
func (m *RpcObjectTypeRelationList) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationList) ProtoMessage()    {}
func (*RpcObjectTypeRelationList) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 3}
}
func (m *RpcObjectTypeRelationList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationList.Merge(m, src)
}
func (m *RpcObjectTypeRelationList) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationList) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationList.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationList proto.InternalMessageInfo

type RpcObjectTypeRelationListRequest struct {
	ObjectTypeUrl                 string `protobuf:"bytes,1,opt,name=objectTypeUrl,proto3" json:"objectTypeUrl,omitempty"`
	AppendRelationsFromOtherTypes bool   `protobuf:"varint,2,opt,name=appendRelationsFromOtherTypes,proto3" json:"appendRelationsFromOtherTypes,omitempty"`
}

func (m *RpcObjectTypeRelationListRequest) Reset()         { *m = RpcObjectTypeRelationListRequest{} }
func (m *RpcObjectTypeRelationListRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationListRequest) ProtoMessage()    {}
func (*RpcObjectTypeRelationListRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 3, 0}
}
func (m *RpcObjectTypeRelationListRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationListRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationListRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationListRequest.Merge(m, src)
}
func (m *RpcObjectTypeRelationListRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationListRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationListRequest proto.InternalMessageInfo

func (m *RpcObjectTypeRelationListRequest) GetObjectTypeUrl() string {
	if m != nil {
		return m.ObjectTypeUrl
	}
	return ""
}

func (m *RpcObjectTypeRelationListRequest) GetAppendRelationsFromOtherTypes() bool {
	if m != nil {
		return m.AppendRelationsFromOtherTypes
	}
	return false
}

type RpcObjectTypeRelationListResponse struct {
	Error     *RpcObjectTypeRelationListResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Relations []*model.Relation                       `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcObjectTypeRelationListResponse) Reset()         { *m = RpcObjectTypeRelationListResponse{} }
func (m *RpcObjectTypeRelationListResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationListResponse) ProtoMessage()    {}
func (*RpcObjectTypeRelationListResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 3, 1}
}
func (m *RpcObjectTypeRelationListResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationListResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationListResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationListResponse.Merge(m, src)
}
func (m *RpcObjectTypeRelationListResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationListResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationListResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationListResponse proto.InternalMessageInfo

func (m *RpcObjectTypeRelationListResponse) GetError() *RpcObjectTypeRelationListResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectTypeRelationListResponse) GetRelations() []*model.Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcObjectTypeRelationListResponseError struct {
	Code        RpcObjectTypeRelationListResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectTypeRelationListResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectTypeRelationListResponseError) Reset() {
	*m = RpcObjectTypeRelationListResponseError{}
}
func (m *RpcObjectTypeRelationListResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectTypeRelationListResponseError) ProtoMessage()    {}
func (*RpcObjectTypeRelationListResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 22, 2, 3, 1, 0}
}
func (m *RpcObjectTypeRelationListResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectTypeRelationListResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectTypeRelationListResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectTypeRelationListResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectTypeRelationListResponseError.Merge(m, src)
}
func (m *RpcObjectTypeRelationListResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectTypeRelationListResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectTypeRelationListResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectTypeRelationListResponseError proto.InternalMessageInfo

func (m *RpcObjectTypeRelationListResponseError) GetCode() RpcObjectTypeRelationListResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectTypeRelationListResponseError_NULL
}

func (m *RpcObjectTypeRelationListResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObject struct {
}

func (m *RpcObject) Reset()         { *m = RpcObject{} }
func (m *RpcObject) String() string { return proto.CompactTextString(m) }
func (*RpcObject) ProtoMessage()    {}
func (*RpcObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23}
}
func (m *RpcObject) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObject.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObject.Merge(m, src)
}
func (m *RpcObject) XXX_Size() int {
	return m.Size()
}
func (m *RpcObject) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObject.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObject proto.InternalMessageInfo

type RpcObjectShareByLink struct {
}

func (m *RpcObjectShareByLink) Reset()         { *m = RpcObjectShareByLink{} }
func (m *RpcObjectShareByLink) String() string { return proto.CompactTextString(m) }
func (*RpcObjectShareByLink) ProtoMessage()    {}
func (*RpcObjectShareByLink) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 0}
}
func (m *RpcObjectShareByLink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectShareByLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectShareByLink.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectShareByLink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectShareByLink.Merge(m, src)
}
func (m *RpcObjectShareByLink) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectShareByLink) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectShareByLink.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectShareByLink proto.InternalMessageInfo

type RpcObjectShareByLinkRequest struct {
	ObjectId string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
}

func (m *RpcObjectShareByLinkRequest) Reset()         { *m = RpcObjectShareByLinkRequest{} }
func (m *RpcObjectShareByLinkRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectShareByLinkRequest) ProtoMessage()    {}
func (*RpcObjectShareByLinkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 0, 0}
}
func (m *RpcObjectShareByLinkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectShareByLinkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectShareByLinkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectShareByLinkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectShareByLinkRequest.Merge(m, src)
}
func (m *RpcObjectShareByLinkRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectShareByLinkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectShareByLinkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectShareByLinkRequest proto.InternalMessageInfo

func (m *RpcObjectShareByLinkRequest) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	return ""
}

type RpcObjectShareByLinkResponse struct {
	Link  string                             `protobuf:"bytes,1,opt,name=link,proto3" json:"link,omitempty"`
	Error *RpcObjectShareByLinkResponseError `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectShareByLinkResponse) Reset()         { *m = RpcObjectShareByLinkResponse{} }
func (m *RpcObjectShareByLinkResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectShareByLinkResponse) ProtoMessage()    {}
func (*RpcObjectShareByLinkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 0, 1}
}
func (m *RpcObjectShareByLinkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectShareByLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectShareByLinkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectShareByLinkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectShareByLinkResponse.Merge(m, src)
}
func (m *RpcObjectShareByLinkResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectShareByLinkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectShareByLinkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectShareByLinkResponse proto.InternalMessageInfo

func (m *RpcObjectShareByLinkResponse) GetLink() string {
	if m != nil {
		return m.Link
	}
	return ""
}

func (m *RpcObjectShareByLinkResponse) GetError() *RpcObjectShareByLinkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectShareByLinkResponseError struct {
	Code        RpcObjectShareByLinkResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectShareByLinkResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectShareByLinkResponseError) Reset()         { *m = RpcObjectShareByLinkResponseError{} }
func (m *RpcObjectShareByLinkResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectShareByLinkResponseError) ProtoMessage()    {}
func (*RpcObjectShareByLinkResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 0, 1, 0}
}
func (m *RpcObjectShareByLinkResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectShareByLinkResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectShareByLinkResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectShareByLinkResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectShareByLinkResponseError.Merge(m, src)
}
func (m *RpcObjectShareByLinkResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectShareByLinkResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectShareByLinkResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectShareByLinkResponseError proto.InternalMessageInfo

func (m *RpcObjectShareByLinkResponseError) GetCode() RpcObjectShareByLinkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectShareByLinkResponseError_NULL
}

func (m *RpcObjectShareByLinkResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectAddWithObjectId struct {
}

func (m *RpcObjectAddWithObjectId) Reset()         { *m = RpcObjectAddWithObjectId{} }
func (m *RpcObjectAddWithObjectId) String() string { return proto.CompactTextString(m) }
func (*RpcObjectAddWithObjectId) ProtoMessage()    {}
func (*RpcObjectAddWithObjectId) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 1}
}
func (m *RpcObjectAddWithObjectId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectAddWithObjectId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectAddWithObjectId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectAddWithObjectId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectAddWithObjectId.Merge(m, src)
}
func (m *RpcObjectAddWithObjectId) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectAddWithObjectId) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectAddWithObjectId.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectAddWithObjectId proto.InternalMessageInfo

type RpcObjectAddWithObjectIdRequest struct {
	ObjectId string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Payload  string `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
}

func (m *RpcObjectAddWithObjectIdRequest) Reset()         { *m = RpcObjectAddWithObjectIdRequest{} }
func (m *RpcObjectAddWithObjectIdRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectAddWithObjectIdRequest) ProtoMessage()    {}
func (*RpcObjectAddWithObjectIdRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 1, 0}
}
func (m *RpcObjectAddWithObjectIdRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectAddWithObjectIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectAddWithObjectIdRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectAddWithObjectIdRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectAddWithObjectIdRequest.Merge(m, src)
}
func (m *RpcObjectAddWithObjectIdRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectAddWithObjectIdRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectAddWithObjectIdRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectAddWithObjectIdRequest proto.InternalMessageInfo

func (m *RpcObjectAddWithObjectIdRequest) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	return ""
}

func (m *RpcObjectAddWithObjectIdRequest) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

type RpcObjectAddWithObjectIdResponse struct {
	Error *RpcObjectAddWithObjectIdResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectAddWithObjectIdResponse) Reset()         { *m = RpcObjectAddWithObjectIdResponse{} }
func (m *RpcObjectAddWithObjectIdResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectAddWithObjectIdResponse) ProtoMessage()    {}
func (*RpcObjectAddWithObjectIdResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 1, 1}
}
func (m *RpcObjectAddWithObjectIdResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectAddWithObjectIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectAddWithObjectIdResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectAddWithObjectIdResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectAddWithObjectIdResponse.Merge(m, src)
}
func (m *RpcObjectAddWithObjectIdResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectAddWithObjectIdResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectAddWithObjectIdResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectAddWithObjectIdResponse proto.InternalMessageInfo

func (m *RpcObjectAddWithObjectIdResponse) GetError() *RpcObjectAddWithObjectIdResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectAddWithObjectIdResponseError struct {
	Code        RpcObjectAddWithObjectIdResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectAddWithObjectIdResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectAddWithObjectIdResponseError) Reset()         { *m = RpcObjectAddWithObjectIdResponseError{} }
func (m *RpcObjectAddWithObjectIdResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectAddWithObjectIdResponseError) ProtoMessage()    {}
func (*RpcObjectAddWithObjectIdResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 1, 1, 0}
}
func (m *RpcObjectAddWithObjectIdResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectAddWithObjectIdResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectAddWithObjectIdResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectAddWithObjectIdResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectAddWithObjectIdResponseError.Merge(m, src)
}
func (m *RpcObjectAddWithObjectIdResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectAddWithObjectIdResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectAddWithObjectIdResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectAddWithObjectIdResponseError proto.InternalMessageInfo

func (m *RpcObjectAddWithObjectIdResponseError) GetCode() RpcObjectAddWithObjectIdResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectAddWithObjectIdResponseError_NULL
}

func (m *RpcObjectAddWithObjectIdResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectRelationAdd struct {
}

func (m *RpcObjectRelationAdd) Reset()         { *m = RpcObjectRelationAdd{} }
func (m *RpcObjectRelationAdd) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationAdd) ProtoMessage()    {}
func (*RpcObjectRelationAdd) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 2}
}
func (m *RpcObjectRelationAdd) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationAdd.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationAdd) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationAdd.Merge(m, src)
}
func (m *RpcObjectRelationAdd) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationAdd) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationAdd.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationAdd proto.InternalMessageInfo

type RpcObjectRelationAddRequest struct {
	ContextId string          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Relation  *model.Relation `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
}

func (m *RpcObjectRelationAddRequest) Reset()         { *m = RpcObjectRelationAddRequest{} }
func (m *RpcObjectRelationAddRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationAddRequest) ProtoMessage()    {}
func (*RpcObjectRelationAddRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 2, 0}
}
func (m *RpcObjectRelationAddRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationAddRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationAddRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationAddRequest.Merge(m, src)
}
func (m *RpcObjectRelationAddRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationAddRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationAddRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationAddRequest proto.InternalMessageInfo

func (m *RpcObjectRelationAddRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectRelationAddRequest) GetRelation() *model.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

type RpcObjectRelationAddResponse struct {
	Error       *RpcObjectRelationAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event       *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	RelationKey string                             `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Relation    *model.Relation                    `protobuf:"bytes,4,opt,name=relation,proto3" json:"relation,omitempty"`
}

func (m *RpcObjectRelationAddResponse) Reset()         { *m = RpcObjectRelationAddResponse{} }
func (m *RpcObjectRelationAddResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationAddResponse) ProtoMessage()    {}
func (*RpcObjectRelationAddResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 2, 1}
}
func (m *RpcObjectRelationAddResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationAddResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationAddResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationAddResponse.Merge(m, src)
}
func (m *RpcObjectRelationAddResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationAddResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationAddResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationAddResponse proto.InternalMessageInfo

func (m *RpcObjectRelationAddResponse) GetError() *RpcObjectRelationAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationAddResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcObjectRelationAddResponse) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *RpcObjectRelationAddResponse) GetRelation() *model.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

type RpcObjectRelationAddResponseError struct {
	Code        RpcObjectRelationAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationAddResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationAddResponseError) Reset()         { *m = RpcObjectRelationAddResponseError{} }
func (m *RpcObjectRelationAddResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationAddResponseError) ProtoMessage()    {}
func (*RpcObjectRelationAddResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 2, 1, 0}
}
func (m *RpcObjectRelationAddResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationAddResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationAddResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationAddResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationAddResponseError.Merge(m, src)
}
func (m *RpcObjectRelationAddResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationAddResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationAddResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationAddResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationAddResponseError) GetCode() RpcObjectRelationAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationAddResponseError_NULL
}

func (m *RpcObjectRelationAddResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectRelationUpdate struct {
}

func (m *RpcObjectRelationUpdate) Reset()         { *m = RpcObjectRelationUpdate{} }
func (m *RpcObjectRelationUpdate) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationUpdate) ProtoMessage()    {}
func (*RpcObjectRelationUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 3}
}
func (m *RpcObjectRelationUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationUpdate.Merge(m, src)
}
func (m *RpcObjectRelationUpdate) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationUpdate proto.InternalMessageInfo

type RpcObjectRelationUpdateRequest struct {
	ContextId   string          `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	RelationKey string          `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Relation    *model.Relation `protobuf:"bytes,3,opt,name=relation,proto3" json:"relation,omitempty"`
}

func (m *RpcObjectRelationUpdateRequest) Reset()         { *m = RpcObjectRelationUpdateRequest{} }
func (m *RpcObjectRelationUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationUpdateRequest) ProtoMessage()    {}
func (*RpcObjectRelationUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 3, 0}
}
func (m *RpcObjectRelationUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationUpdateRequest.Merge(m, src)
}
func (m *RpcObjectRelationUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationUpdateRequest proto.InternalMessageInfo

func (m *RpcObjectRelationUpdateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectRelationUpdateRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *RpcObjectRelationUpdateRequest) GetRelation() *model.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

type RpcObjectRelationUpdateResponse struct {
	Error *RpcObjectRelationUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectRelationUpdateResponse) Reset()         { *m = RpcObjectRelationUpdateResponse{} }
func (m *RpcObjectRelationUpdateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationUpdateResponse) ProtoMessage()    {}
func (*RpcObjectRelationUpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 3, 1}
}
func (m *RpcObjectRelationUpdateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationUpdateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationUpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationUpdateResponse.Merge(m, src)
}
func (m *RpcObjectRelationUpdateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationUpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationUpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationUpdateResponse proto.InternalMessageInfo

func (m *RpcObjectRelationUpdateResponse) GetError() *RpcObjectRelationUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectRelationUpdateResponseError struct {
	Code        RpcObjectRelationUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationUpdateResponseError) Reset()         { *m = RpcObjectRelationUpdateResponseError{} }
func (m *RpcObjectRelationUpdateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationUpdateResponseError) ProtoMessage()    {}
func (*RpcObjectRelationUpdateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 3, 1, 0}
}
func (m *RpcObjectRelationUpdateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationUpdateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationUpdateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationUpdateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationUpdateResponseError.Merge(m, src)
}
func (m *RpcObjectRelationUpdateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationUpdateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationUpdateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationUpdateResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationUpdateResponseError) GetCode() RpcObjectRelationUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationUpdateResponseError_NULL
}

func (m *RpcObjectRelationUpdateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectRelationDelete struct {
}

func (m *RpcObjectRelationDelete) Reset()         { *m = RpcObjectRelationDelete{} }
func (m *RpcObjectRelationDelete) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationDelete) ProtoMessage()    {}
func (*RpcObjectRelationDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 4}
}
func (m *RpcObjectRelationDelete) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationDelete.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationDelete.Merge(m, src)
}
func (m *RpcObjectRelationDelete) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationDelete.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationDelete proto.InternalMessageInfo

type RpcObjectRelationDeleteRequest struct {
	ContextId   string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	RelationKey string `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
}

func (m *RpcObjectRelationDeleteRequest) Reset()         { *m = RpcObjectRelationDeleteRequest{} }
func (m *RpcObjectRelationDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationDeleteRequest) ProtoMessage()    {}
func (*RpcObjectRelationDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 4, 0}
}
func (m *RpcObjectRelationDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationDeleteRequest.Merge(m, src)
}
func (m *RpcObjectRelationDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationDeleteRequest proto.InternalMessageInfo

func (m *RpcObjectRelationDeleteRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectRelationDeleteRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

type RpcObjectRelationDeleteResponse struct {
	Error *RpcObjectRelationDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectRelationDeleteResponse) Reset()         { *m = RpcObjectRelationDeleteResponse{} }
func (m *RpcObjectRelationDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationDeleteResponse) ProtoMessage()    {}
func (*RpcObjectRelationDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 4, 1}
}
func (m *RpcObjectRelationDeleteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationDeleteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationDeleteResponse.Merge(m, src)
}
func (m *RpcObjectRelationDeleteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationDeleteResponse proto.InternalMessageInfo

func (m *RpcObjectRelationDeleteResponse) GetError() *RpcObjectRelationDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectRelationDeleteResponseError struct {
	Code        RpcObjectRelationDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationDeleteResponseError) Reset()         { *m = RpcObjectRelationDeleteResponseError{} }
func (m *RpcObjectRelationDeleteResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationDeleteResponseError) ProtoMessage()    {}
func (*RpcObjectRelationDeleteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 4, 1, 0}
}
func (m *RpcObjectRelationDeleteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationDeleteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationDeleteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationDeleteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationDeleteResponseError.Merge(m, src)
}
func (m *RpcObjectRelationDeleteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationDeleteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationDeleteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationDeleteResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationDeleteResponseError) GetCode() RpcObjectRelationDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationDeleteResponseError_NULL
}

func (m *RpcObjectRelationDeleteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

// RelationOptionAdd may return existing option in case dataview already has one with the same text
type RpcObjectRelationOptionAdd struct {
}

func (m *RpcObjectRelationOptionAdd) Reset()         { *m = RpcObjectRelationOptionAdd{} }
func (m *RpcObjectRelationOptionAdd) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionAdd) ProtoMessage()    {}
func (*RpcObjectRelationOptionAdd) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 5}
}
func (m *RpcObjectRelationOptionAdd) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionAdd.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionAdd) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionAdd.Merge(m, src)
}
func (m *RpcObjectRelationOptionAdd) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionAdd) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionAdd.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionAdd proto.InternalMessageInfo

type RpcObjectRelationOptionAddRequest struct {
	ContextId   string                `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	RelationKey string                `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Option      *model.RelationOption `protobuf:"bytes,3,opt,name=option,proto3" json:"option,omitempty"`
}

func (m *RpcObjectRelationOptionAddRequest) Reset()         { *m = RpcObjectRelationOptionAddRequest{} }
func (m *RpcObjectRelationOptionAddRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionAddRequest) ProtoMessage()    {}
func (*RpcObjectRelationOptionAddRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 5, 0}
}
func (m *RpcObjectRelationOptionAddRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionAddRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionAddRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionAddRequest.Merge(m, src)
}
func (m *RpcObjectRelationOptionAddRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionAddRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionAddRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionAddRequest proto.InternalMessageInfo

func (m *RpcObjectRelationOptionAddRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectRelationOptionAddRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *RpcObjectRelationOptionAddRequest) GetOption() *model.RelationOption {
	if m != nil {
		return m.Option
	}
	return nil
}

type RpcObjectRelationOptionAddResponse struct {
	Error  *RpcObjectRelationOptionAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event  *ResponseEvent                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	Option *model.RelationOption                    `protobuf:"bytes,3,opt,name=option,proto3" json:"option,omitempty"`
}

func (m *RpcObjectRelationOptionAddResponse) Reset()         { *m = RpcObjectRelationOptionAddResponse{} }
func (m *RpcObjectRelationOptionAddResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionAddResponse) ProtoMessage()    {}
func (*RpcObjectRelationOptionAddResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 5, 1}
}
func (m *RpcObjectRelationOptionAddResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionAddResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionAddResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionAddResponse.Merge(m, src)
}
func (m *RpcObjectRelationOptionAddResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionAddResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionAddResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionAddResponse proto.InternalMessageInfo

func (m *RpcObjectRelationOptionAddResponse) GetError() *RpcObjectRelationOptionAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationOptionAddResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcObjectRelationOptionAddResponse) GetOption() *model.RelationOption {
	if m != nil {
		return m.Option
	}
	return nil
}

type RpcObjectRelationOptionAddResponseError struct {
	Code        RpcObjectRelationOptionAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationOptionAddResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationOptionAddResponseError) Reset() {
	*m = RpcObjectRelationOptionAddResponseError{}
}
func (m *RpcObjectRelationOptionAddResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionAddResponseError) ProtoMessage()    {}
func (*RpcObjectRelationOptionAddResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 5, 1, 0}
}
func (m *RpcObjectRelationOptionAddResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionAddResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionAddResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionAddResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionAddResponseError.Merge(m, src)
}
func (m *RpcObjectRelationOptionAddResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionAddResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionAddResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionAddResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationOptionAddResponseError) GetCode() RpcObjectRelationOptionAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationOptionAddResponseError_NULL
}

func (m *RpcObjectRelationOptionAddResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectRelationOptionUpdate struct {
}

func (m *RpcObjectRelationOptionUpdate) Reset()         { *m = RpcObjectRelationOptionUpdate{} }
func (m *RpcObjectRelationOptionUpdate) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionUpdate) ProtoMessage()    {}
func (*RpcObjectRelationOptionUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 6}
}
func (m *RpcObjectRelationOptionUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionUpdate.Merge(m, src)
}
func (m *RpcObjectRelationOptionUpdate) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionUpdate proto.InternalMessageInfo

type RpcObjectRelationOptionUpdateRequest struct {
	ContextId   string                `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	RelationKey string                `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Option      *model.RelationOption `protobuf:"bytes,3,opt,name=option,proto3" json:"option,omitempty"`
}

func (m *RpcObjectRelationOptionUpdateRequest) Reset()         { *m = RpcObjectRelationOptionUpdateRequest{} }
func (m *RpcObjectRelationOptionUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionUpdateRequest) ProtoMessage()    {}
func (*RpcObjectRelationOptionUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 6, 0}
}
func (m *RpcObjectRelationOptionUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionUpdateRequest.Merge(m, src)
}
func (m *RpcObjectRelationOptionUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionUpdateRequest proto.InternalMessageInfo

func (m *RpcObjectRelationOptionUpdateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectRelationOptionUpdateRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *RpcObjectRelationOptionUpdateRequest) GetOption() *model.RelationOption {
	if m != nil {
		return m.Option
	}
	return nil
}

type RpcObjectRelationOptionUpdateResponse struct {
	Error *RpcObjectRelationOptionUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectRelationOptionUpdateResponse) Reset()         { *m = RpcObjectRelationOptionUpdateResponse{} }
func (m *RpcObjectRelationOptionUpdateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionUpdateResponse) ProtoMessage()    {}
func (*RpcObjectRelationOptionUpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 6, 1}
}
func (m *RpcObjectRelationOptionUpdateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionUpdateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionUpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionUpdateResponse.Merge(m, src)
}
func (m *RpcObjectRelationOptionUpdateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionUpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionUpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionUpdateResponse proto.InternalMessageInfo

func (m *RpcObjectRelationOptionUpdateResponse) GetError() *RpcObjectRelationOptionUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationOptionUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectRelationOptionUpdateResponseError struct {
	Code        RpcObjectRelationOptionUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationOptionUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationOptionUpdateResponseError) Reset() {
	*m = RpcObjectRelationOptionUpdateResponseError{}
}
func (m *RpcObjectRelationOptionUpdateResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcObjectRelationOptionUpdateResponseError) ProtoMessage() {}
func (*RpcObjectRelationOptionUpdateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 6, 1, 0}
}
func (m *RpcObjectRelationOptionUpdateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionUpdateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionUpdateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionUpdateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionUpdateResponseError.Merge(m, src)
}
func (m *RpcObjectRelationOptionUpdateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionUpdateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionUpdateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionUpdateResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationOptionUpdateResponseError) GetCode() RpcObjectRelationOptionUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationOptionUpdateResponseError_NULL
}

func (m *RpcObjectRelationOptionUpdateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectRelationOptionDelete struct {
}

func (m *RpcObjectRelationOptionDelete) Reset()         { *m = RpcObjectRelationOptionDelete{} }
func (m *RpcObjectRelationOptionDelete) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionDelete) ProtoMessage()    {}
func (*RpcObjectRelationOptionDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 7}
}
func (m *RpcObjectRelationOptionDelete) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionDelete.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionDelete.Merge(m, src)
}
func (m *RpcObjectRelationOptionDelete) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionDelete.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionDelete proto.InternalMessageInfo

type RpcObjectRelationOptionDeleteRequest struct {
	ContextId                       string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	RelationKey                     string `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	OptionId                        string `protobuf:"bytes,3,opt,name=optionId,proto3" json:"optionId,omitempty"`
	ConfirmRemoveAllValuesInRecords bool   `protobuf:"varint,4,opt,name=confirmRemoveAllValuesInRecords,proto3" json:"confirmRemoveAllValuesInRecords,omitempty"`
}

func (m *RpcObjectRelationOptionDeleteRequest) Reset()         { *m = RpcObjectRelationOptionDeleteRequest{} }
func (m *RpcObjectRelationOptionDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionDeleteRequest) ProtoMessage()    {}
func (*RpcObjectRelationOptionDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 7, 0}
}
func (m *RpcObjectRelationOptionDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionDeleteRequest.Merge(m, src)
}
func (m *RpcObjectRelationOptionDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionDeleteRequest proto.InternalMessageInfo

func (m *RpcObjectRelationOptionDeleteRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectRelationOptionDeleteRequest) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

func (m *RpcObjectRelationOptionDeleteRequest) GetOptionId() string {
	if m != nil {
		return m.OptionId
	}
	return ""
}

func (m *RpcObjectRelationOptionDeleteRequest) GetConfirmRemoveAllValuesInRecords() bool {
	if m != nil {
		return m.ConfirmRemoveAllValuesInRecords
	}
	return false
}

type RpcObjectRelationOptionDeleteResponse struct {
	Error *RpcObjectRelationOptionDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectRelationOptionDeleteResponse) Reset()         { *m = RpcObjectRelationOptionDeleteResponse{} }
func (m *RpcObjectRelationOptionDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationOptionDeleteResponse) ProtoMessage()    {}
func (*RpcObjectRelationOptionDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 7, 1}
}
func (m *RpcObjectRelationOptionDeleteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionDeleteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionDeleteResponse.Merge(m, src)
}
func (m *RpcObjectRelationOptionDeleteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionDeleteResponse proto.InternalMessageInfo

func (m *RpcObjectRelationOptionDeleteResponse) GetError() *RpcObjectRelationOptionDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationOptionDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectRelationOptionDeleteResponseError struct {
	Code        RpcObjectRelationOptionDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationOptionDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationOptionDeleteResponseError) Reset() {
	*m = RpcObjectRelationOptionDeleteResponseError{}
}
func (m *RpcObjectRelationOptionDeleteResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcObjectRelationOptionDeleteResponseError) ProtoMessage() {}
func (*RpcObjectRelationOptionDeleteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 7, 1, 0}
}
func (m *RpcObjectRelationOptionDeleteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationOptionDeleteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationOptionDeleteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationOptionDeleteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationOptionDeleteResponseError.Merge(m, src)
}
func (m *RpcObjectRelationOptionDeleteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationOptionDeleteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationOptionDeleteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationOptionDeleteResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationOptionDeleteResponseError) GetCode() RpcObjectRelationOptionDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationOptionDeleteResponseError_NULL
}

func (m *RpcObjectRelationOptionDeleteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectRelationListAvailable struct {
}

func (m *RpcObjectRelationListAvailable) Reset()         { *m = RpcObjectRelationListAvailable{} }
func (m *RpcObjectRelationListAvailable) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationListAvailable) ProtoMessage()    {}
func (*RpcObjectRelationListAvailable) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 8}
}
func (m *RpcObjectRelationListAvailable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationListAvailable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationListAvailable.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationListAvailable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationListAvailable.Merge(m, src)
}
func (m *RpcObjectRelationListAvailable) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationListAvailable) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationListAvailable.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationListAvailable proto.InternalMessageInfo

type RpcObjectRelationListAvailableRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

func (m *RpcObjectRelationListAvailableRequest) Reset()         { *m = RpcObjectRelationListAvailableRequest{} }
func (m *RpcObjectRelationListAvailableRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationListAvailableRequest) ProtoMessage()    {}
func (*RpcObjectRelationListAvailableRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 8, 0}
}
func (m *RpcObjectRelationListAvailableRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationListAvailableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationListAvailableRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationListAvailableRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationListAvailableRequest.Merge(m, src)
}
func (m *RpcObjectRelationListAvailableRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationListAvailableRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationListAvailableRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationListAvailableRequest proto.InternalMessageInfo

func (m *RpcObjectRelationListAvailableRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

type RpcObjectRelationListAvailableResponse struct {
	Error     *RpcObjectRelationListAvailableResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Relations []*model.Relation                            `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcObjectRelationListAvailableResponse) Reset() {
	*m = RpcObjectRelationListAvailableResponse{}
}
func (m *RpcObjectRelationListAvailableResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationListAvailableResponse) ProtoMessage()    {}
func (*RpcObjectRelationListAvailableResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 8, 1}
}
func (m *RpcObjectRelationListAvailableResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationListAvailableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationListAvailableResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationListAvailableResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationListAvailableResponse.Merge(m, src)
}
func (m *RpcObjectRelationListAvailableResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationListAvailableResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationListAvailableResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationListAvailableResponse proto.InternalMessageInfo

func (m *RpcObjectRelationListAvailableResponse) GetError() *RpcObjectRelationListAvailableResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationListAvailableResponse) GetRelations() []*model.Relation {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcObjectRelationListAvailableResponseError struct {
	Code        RpcObjectRelationListAvailableResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectRelationListAvailableResponseErrorCode" json:"code,omitempty"`
	Description string                                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectRelationListAvailableResponseError) Reset() {
	*m = RpcObjectRelationListAvailableResponseError{}
}
func (m *RpcObjectRelationListAvailableResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcObjectRelationListAvailableResponseError) ProtoMessage() {}
func (*RpcObjectRelationListAvailableResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 8, 1, 0}
}
func (m *RpcObjectRelationListAvailableResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationListAvailableResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationListAvailableResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationListAvailableResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationListAvailableResponseError.Merge(m, src)
}
func (m *RpcObjectRelationListAvailableResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationListAvailableResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationListAvailableResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationListAvailableResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationListAvailableResponseError) GetCode() RpcObjectRelationListAvailableResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationListAvailableResponseError_NULL
}

func (m *RpcObjectRelationListAvailableResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectSearch struct {
}

func (m *RpcObjectSearch) Reset()         { *m = RpcObjectSearch{} }
func (m *RpcObjectSearch) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearch) ProtoMessage()    {}
func (*RpcObjectSearch) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 9}
}
func (m *RpcObjectSearch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearch.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearch.Merge(m, src)
}
func (m *RpcObjectSearch) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearch) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearch.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearch proto.InternalMessageInfo

type RpcObjectSearchRequest struct {
	Filters  []*model.BlockContentDataviewFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	Sorts    []*model.BlockContentDataviewSort   `protobuf:"bytes,2,rep,name=sorts,proto3" json:"sorts,omitempty"`
	FullText string                              `protobuf:"bytes,3,opt,name=fullText,proto3" json:"fullText,omitempty"`
	Offset   int32                               `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit    int32                               `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
	// additional filter by objectTypes
	ObjectTypeFilter []string `protobuf:"bytes,6,rep,name=objectTypeFilter,proto3" json:"objectTypeFilter,omitempty"`
	// needed keys in details for return, when empty - will return all
	Keys []string `protobuf:"bytes,7,rep,name=keys,proto3" json:"keys,omitempty"`
}

func (m *RpcObjectSearchRequest) Reset()         { *m = RpcObjectSearchRequest{} }
func (m *RpcObjectSearchRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchRequest) ProtoMessage()    {}
func (*RpcObjectSearchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 9, 0}
}
func (m *RpcObjectSearchRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchRequest.Merge(m, src)
}
func (m *RpcObjectSearchRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchRequest proto.InternalMessageInfo

func (m *RpcObjectSearchRequest) GetFilters() []*model.BlockContentDataviewFilter {
	if m != nil {
		return m.Filters
	}
	return nil
}

func (m *RpcObjectSearchRequest) GetSorts() []*model.BlockContentDataviewSort {
	if m != nil {
		return m.Sorts
	}
	return nil
}

func (m *RpcObjectSearchRequest) GetFullText() string {
	if m != nil {
		return m.FullText
	}
	return ""
}

func (m *RpcObjectSearchRequest) GetOffset() int32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *RpcObjectSearchRequest) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RpcObjectSearchRequest) GetObjectTypeFilter() []string {
	if m != nil {
		return m.ObjectTypeFilter
	}
	return nil
}

func (m *RpcObjectSearchRequest) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

type RpcObjectSearchResponse struct {
	Error   *RpcObjectSearchResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Records []*types.Struct               `protobuf:"bytes,2,rep,name=records,proto3" json:"records,omitempty"`
}

func (m *RpcObjectSearchResponse) Reset()         { *m = RpcObjectSearchResponse{} }
func (m *RpcObjectSearchResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchResponse) ProtoMessage()    {}
func (*RpcObjectSearchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 9, 1}
}
func (m *RpcObjectSearchResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchResponse.Merge(m, src)
}
func (m *RpcObjectSearchResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchResponse proto.InternalMessageInfo

func (m *RpcObjectSearchResponse) GetError() *RpcObjectSearchResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSearchResponse) GetRecords() []*types.Struct {
	if m != nil {
		return m.Records
	}
	return nil
}

type RpcObjectSearchResponseError struct {
	Code        RpcObjectSearchResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectSearchResponseErrorCode" json:"code,omitempty"`
	Description string                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectSearchResponseError) Reset()         { *m = RpcObjectSearchResponseError{} }
func (m *RpcObjectSearchResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchResponseError) ProtoMessage()    {}
func (*RpcObjectSearchResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 9, 1, 0}
}
func (m *RpcObjectSearchResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchResponseError.Merge(m, src)
}
func (m *RpcObjectSearchResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchResponseError proto.InternalMessageInfo

func (m *RpcObjectSearchResponseError) GetCode() RpcObjectSearchResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSearchResponseError_NULL
}

func (m *RpcObjectSearchResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectGraph struct {
}

func (m *RpcObjectGraph) Reset()         { *m = RpcObjectGraph{} }
func (m *RpcObjectGraph) String() string { return proto.CompactTextString(m) }
func (*RpcObjectGraph) ProtoMessage()    {}
func (*RpcObjectGraph) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10}
}
func (m *RpcObjectGraph) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectGraph) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectGraph.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectGraph) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectGraph.Merge(m, src)
}
func (m *RpcObjectGraph) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectGraph) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectGraph.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectGraph proto.InternalMessageInfo

type RpcObjectGraphRequest struct {
	Filters []*model.BlockContentDataviewFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	Limit   int32                               `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	// additional filter by objectTypes
	ObjectTypeFilter []string `protobuf:"bytes,3,rep,name=objectTypeFilter,proto3" json:"objectTypeFilter,omitempty"`
}

func (m *RpcObjectGraphRequest) Reset()         { *m = RpcObjectGraphRequest{} }
func (m *RpcObjectGraphRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectGraphRequest) ProtoMessage()    {}
func (*RpcObjectGraphRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 0}
}
func (m *RpcObjectGraphRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectGraphRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectGraphRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectGraphRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectGraphRequest.Merge(m, src)
}
func (m *RpcObjectGraphRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectGraphRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectGraphRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectGraphRequest proto.InternalMessageInfo

func (m *RpcObjectGraphRequest) GetFilters() []*model.BlockContentDataviewFilter {
	if m != nil {
		return m.Filters
	}
	return nil
}

func (m *RpcObjectGraphRequest) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RpcObjectGraphRequest) GetObjectTypeFilter() []string {
	if m != nil {
		return m.ObjectTypeFilter
	}
	return nil
}

type RpcObjectGraphNode struct {
	Id             string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type           string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	Name           string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Layout         int32  `protobuf:"varint,4,opt,name=layout,proto3" json:"layout,omitempty"`
	Description    string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	IconImage      string `protobuf:"bytes,6,opt,name=iconImage,proto3" json:"iconImage,omitempty"`
	IconEmoji      string `protobuf:"bytes,7,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"`
	Done           bool   `protobuf:"varint,8,opt,name=done,proto3" json:"done,omitempty"`
	RelationFormat int32  `protobuf:"varint,9,opt,name=relationFormat,proto3" json:"relationFormat,omitempty"`
	Snippet        string `protobuf:"bytes,10,opt,name=snippet,proto3" json:"snippet,omitempty"`
}

func (m *RpcObjectGraphNode) Reset()         { *m = RpcObjectGraphNode{} }
func (m *RpcObjectGraphNode) String() string { return proto.CompactTextString(m) }
func (*RpcObjectGraphNode) ProtoMessage()    {}
func (*RpcObjectGraphNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 1}
}
func (m *RpcObjectGraphNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectGraphNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectGraphNode.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectGraphNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectGraphNode.Merge(m, src)
}
func (m *RpcObjectGraphNode) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectGraphNode) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectGraphNode.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectGraphNode proto.InternalMessageInfo

func (m *RpcObjectGraphNode) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcObjectGraphNode) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *RpcObjectGraphNode) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RpcObjectGraphNode) GetLayout() int32 {
	if m != nil {
		return m.Layout
	}
	return 0
}

func (m *RpcObjectGraphNode) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *RpcObjectGraphNode) GetIconImage() string {
	if m != nil {
		return m.IconImage
	}
	return ""
}

func (m *RpcObjectGraphNode) GetIconEmoji() string {
	if m != nil {
		return m.IconEmoji
	}
	return ""
}

func (m *RpcObjectGraphNode) GetDone() bool {
	if m != nil {
		return m.Done
	}
	return false
}

func (m *RpcObjectGraphNode) GetRelationFormat() int32 {
	if m != nil {
		return m.RelationFormat
	}
	return 0
}

func (m *RpcObjectGraphNode) GetSnippet() string {
	if m != nil {
		return m.Snippet
	}
	return ""
}

type RpcObjectGraphEdge struct {
	Source      string                 `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	Target      string                 `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	Name        string                 `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Type        RpcObjectGraphEdgeType `protobuf:"varint,4,opt,name=type,proto3,enum=anytype.RpcObjectGraphEdgeType" json:"type,omitempty"`
	Description string                 `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	IconImage   string                 `protobuf:"bytes,6,opt,name=iconImage,proto3" json:"iconImage,omitempty"`
	IconEmoji   string                 `protobuf:"bytes,7,opt,name=iconEmoji,proto3" json:"iconEmoji,omitempty"`
	Hidden      bool                   `protobuf:"varint,8,opt,name=hidden,proto3" json:"hidden,omitempty"`
}

func (m *RpcObjectGraphEdge) Reset()         { *m = RpcObjectGraphEdge{} }
func (m *RpcObjectGraphEdge) String() string { return proto.CompactTextString(m) }
func (*RpcObjectGraphEdge) ProtoMessage()    {}
func (*RpcObjectGraphEdge) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 2}
}
func (m *RpcObjectGraphEdge) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectGraphEdge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectGraphEdge.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectGraphEdge) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectGraphEdge.Merge(m, src)
}
func (m *RpcObjectGraphEdge) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectGraphEdge) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectGraphEdge.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectGraphEdge proto.InternalMessageInfo

func (m *RpcObjectGraphEdge) GetSource() string {
	if m != nil {
		return m.Source
	}
	return ""
}

func (m *RpcObjectGraphEdge) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *RpcObjectGraphEdge) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RpcObjectGraphEdge) GetType() RpcObjectGraphEdgeType {
	if m != nil {
		return m.Type
	}
	return RpcObjectGraphEdge_Link
}

func (m *RpcObjectGraphEdge) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *RpcObjectGraphEdge) GetIconImage() string {
	if m != nil {
		return m.IconImage
	}
	return ""
}

func (m *RpcObjectGraphEdge) GetIconEmoji() string {
	if m != nil {
		return m.IconEmoji
	}
	return ""
}

func (m *RpcObjectGraphEdge) GetHidden() bool {
	if m != nil {
		return m.Hidden
	}
	return false
}

type RpcObjectGraphResponse struct {
	Error *RpcObjectGraphResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Nodes []*RpcObjectGraphNode        `protobuf:"bytes,2,rep,name=nodes,proto3" json:"nodes,omitempty"`
	Edges []*RpcObjectGraphEdge        `protobuf:"bytes,3,rep,name=edges,proto3" json:"edges,omitempty"`
}

func (m *RpcObjectGraphResponse) Reset()         { *m = RpcObjectGraphResponse{} }
func (m *RpcObjectGraphResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectGraphResponse) ProtoMessage()    {}
func (*RpcObjectGraphResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 3}
}
func (m *RpcObjectGraphResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectGraphResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectGraphResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectGraphResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectGraphResponse.Merge(m, src)
}
func (m *RpcObjectGraphResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectGraphResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectGraphResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectGraphResponse proto.InternalMessageInfo

func (m *RpcObjectGraphResponse) GetError() *RpcObjectGraphResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectGraphResponse) GetNodes() []*RpcObjectGraphNode {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *RpcObjectGraphResponse) GetEdges() []*RpcObjectGraphEdge {
	if m != nil {
		return m.Edges
	}
	return nil
}

type RpcObjectGraphResponseError struct {
	Code        RpcObjectGraphResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectGraphResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectGraphResponseError) Reset()         { *m = RpcObjectGraphResponseError{} }
func (m *RpcObjectGraphResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectGraphResponseError) ProtoMessage()    {}
func (*RpcObjectGraphResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 10, 3, 0}
}
func (m *RpcObjectGraphResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectGraphResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectGraphResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectGraphResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectGraphResponseError.Merge(m, src)
}
func (m *RpcObjectGraphResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectGraphResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectGraphResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectGraphResponseError proto.InternalMessageInfo

func (m *RpcObjectGraphResponseError) GetCode() RpcObjectGraphResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectGraphResponseError_NULL
}

func (m *RpcObjectGraphResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectSearchSubscribe struct {
}

func (m *RpcObjectSearchSubscribe) Reset()         { *m = RpcObjectSearchSubscribe{} }
func (m *RpcObjectSearchSubscribe) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchSubscribe) ProtoMessage()    {}
func (*RpcObjectSearchSubscribe) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 11}
}
func (m *RpcObjectSearchSubscribe) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchSubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchSubscribe.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchSubscribe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchSubscribe.Merge(m, src)
}
func (m *RpcObjectSearchSubscribe) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchSubscribe) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchSubscribe.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchSubscribe proto.InternalMessageInfo

type RpcObjectSearchSubscribeRequest struct {
	// (optional) subscription identifier
	// client can provide some string or middleware will generate it automatically
	// if subId is already registered on middleware, the new query will replace previous subscription
	SubId string `protobuf:"bytes,1,opt,name=subId,proto3" json:"subId,omitempty"`
	// filters
	Filters []*model.BlockContentDataviewFilter `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"`
	// sorts
	Sorts []*model.BlockContentDataviewSort `protobuf:"bytes,3,rep,name=sorts,proto3" json:"sorts,omitempty"`
	// results limit
	Limit int64 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
	// initial offset; middleware will find afterId
	Offset int64 `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"`
	// (required)  needed keys in details for return, for object fields mw will return (and subscribe) objects as dependent
	Keys []string `protobuf:"bytes,7,rep,name=keys,proto3" json:"keys,omitempty"`
	// (optional) pagination: middleware will return results after given id
	AfterId string `protobuf:"bytes,8,opt,name=afterId,proto3" json:"afterId,omitempty"`
	// (optional) pagination: middleware will return results before given id
	BeforeId        string   `protobuf:"bytes,9,opt,name=beforeId,proto3" json:"beforeId,omitempty"`
	Source          []string `protobuf:"bytes,10,rep,name=source,proto3" json:"source,omitempty"`
	IgnoreWorkspace string   `protobuf:"bytes,12,opt,name=ignoreWorkspace,proto3" json:"ignoreWorkspace,omitempty"`
	// disable dependent subscription
	NoDepSubscription bool `protobuf:"varint,13,opt,name=noDepSubscription,proto3" json:"noDepSubscription,omitempty"`
}

func (m *RpcObjectSearchSubscribeRequest) Reset()         { *m = RpcObjectSearchSubscribeRequest{} }
func (m *RpcObjectSearchSubscribeRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchSubscribeRequest) ProtoMessage()    {}
func (*RpcObjectSearchSubscribeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 11, 0}
}
func (m *RpcObjectSearchSubscribeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchSubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchSubscribeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchSubscribeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchSubscribeRequest.Merge(m, src)
}
func (m *RpcObjectSearchSubscribeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchSubscribeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchSubscribeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchSubscribeRequest proto.InternalMessageInfo

func (m *RpcObjectSearchSubscribeRequest) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

func (m *RpcObjectSearchSubscribeRequest) GetFilters() []*model.BlockContentDataviewFilter {
	if m != nil {
		return m.Filters
	}
	return nil
}

func (m *RpcObjectSearchSubscribeRequest) GetSorts() []*model.BlockContentDataviewSort {
	if m != nil {
		return m.Sorts
	}
	return nil
}

func (m *RpcObjectSearchSubscribeRequest) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *RpcObjectSearchSubscribeRequest) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *RpcObjectSearchSubscribeRequest) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *RpcObjectSearchSubscribeRequest) GetAfterId() string {
	if m != nil {
		return m.AfterId
	}
	return ""
}

func (m *RpcObjectSearchSubscribeRequest) GetBeforeId() string {
	if m != nil {
		return m.BeforeId
	}
	return ""
}

func (m *RpcObjectSearchSubscribeRequest) GetSource() []string {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *RpcObjectSearchSubscribeRequest) GetIgnoreWorkspace() string {
	if m != nil {
		return m.IgnoreWorkspace
	}
	return ""
}

func (m *RpcObjectSearchSubscribeRequest) GetNoDepSubscription() bool {
	if m != nil {
		return m.NoDepSubscription
	}
	return false
}

type RpcObjectSearchSubscribeResponse struct {
	Error        *RpcObjectSearchSubscribeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Records      []*types.Struct                        `protobuf:"bytes,2,rep,name=records,proto3" json:"records,omitempty"`
	Dependencies []*types.Struct                        `protobuf:"bytes,3,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	SubId        string                                 `protobuf:"bytes,4,opt,name=subId,proto3" json:"subId,omitempty"`
	Counters     *EventObjectSubscriptionCounters       `protobuf:"bytes,5,opt,name=counters,proto3" json:"counters,omitempty"`
}

func (m *RpcObjectSearchSubscribeResponse) Reset()         { *m = RpcObjectSearchSubscribeResponse{} }
func (m *RpcObjectSearchSubscribeResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchSubscribeResponse) ProtoMessage()    {}
func (*RpcObjectSearchSubscribeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 11, 1}
}
func (m *RpcObjectSearchSubscribeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchSubscribeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchSubscribeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchSubscribeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchSubscribeResponse.Merge(m, src)
}
func (m *RpcObjectSearchSubscribeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchSubscribeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchSubscribeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchSubscribeResponse proto.InternalMessageInfo

func (m *RpcObjectSearchSubscribeResponse) GetError() *RpcObjectSearchSubscribeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSearchSubscribeResponse) GetRecords() []*types.Struct {
	if m != nil {
		return m.Records
	}
	return nil
}

func (m *RpcObjectSearchSubscribeResponse) GetDependencies() []*types.Struct {
	if m != nil {
		return m.Dependencies
	}
	return nil
}

func (m *RpcObjectSearchSubscribeResponse) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

func (m *RpcObjectSearchSubscribeResponse) GetCounters() *EventObjectSubscriptionCounters {
	if m != nil {
		return m.Counters
	}
	return nil
}

type RpcObjectSearchSubscribeResponseError struct {
	Code        RpcObjectSearchSubscribeResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectSearchSubscribeResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectSearchSubscribeResponseError) Reset()         { *m = RpcObjectSearchSubscribeResponseError{} }
func (m *RpcObjectSearchSubscribeResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchSubscribeResponseError) ProtoMessage()    {}
func (*RpcObjectSearchSubscribeResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 11, 1, 0}
}
func (m *RpcObjectSearchSubscribeResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchSubscribeResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchSubscribeResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchSubscribeResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchSubscribeResponseError.Merge(m, src)
}
func (m *RpcObjectSearchSubscribeResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchSubscribeResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchSubscribeResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchSubscribeResponseError proto.InternalMessageInfo

func (m *RpcObjectSearchSubscribeResponseError) GetCode() RpcObjectSearchSubscribeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSearchSubscribeResponseError_NULL
}

func (m *RpcObjectSearchSubscribeResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectIdsSubscribe struct {
}

func (m *RpcObjectIdsSubscribe) Reset()         { *m = RpcObjectIdsSubscribe{} }
func (m *RpcObjectIdsSubscribe) String() string { return proto.CompactTextString(m) }
func (*RpcObjectIdsSubscribe) ProtoMessage()    {}
func (*RpcObjectIdsSubscribe) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 12}
}
func (m *RpcObjectIdsSubscribe) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectIdsSubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectIdsSubscribe.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectIdsSubscribe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectIdsSubscribe.Merge(m, src)
}
func (m *RpcObjectIdsSubscribe) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectIdsSubscribe) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectIdsSubscribe.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectIdsSubscribe proto.InternalMessageInfo

type RpcObjectIdsSubscribeRequest struct {
	// (optional) subscription identifier
	// client can provide some string or middleware will generate it automatically
	// if subId is already registered on middleware, the new query will replace previous subscription
	SubId string `protobuf:"bytes,1,opt,name=subId,proto3" json:"subId,omitempty"`
	// ids for subscribe
	Ids []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
	// sorts
	// (required)  needed keys in details for return, for object fields mw will return (and subscribe) objects as dependent
	Keys            []string `protobuf:"bytes,3,rep,name=keys,proto3" json:"keys,omitempty"`
	IgnoreWorkspace string   `protobuf:"bytes,11,opt,name=ignoreWorkspace,proto3" json:"ignoreWorkspace,omitempty"`
}

func (m *RpcObjectIdsSubscribeRequest) Reset()         { *m = RpcObjectIdsSubscribeRequest{} }
func (m *RpcObjectIdsSubscribeRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectIdsSubscribeRequest) ProtoMessage()    {}
func (*RpcObjectIdsSubscribeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 12, 0}
}
func (m *RpcObjectIdsSubscribeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectIdsSubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectIdsSubscribeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectIdsSubscribeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectIdsSubscribeRequest.Merge(m, src)
}
func (m *RpcObjectIdsSubscribeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectIdsSubscribeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectIdsSubscribeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectIdsSubscribeRequest proto.InternalMessageInfo

func (m *RpcObjectIdsSubscribeRequest) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

func (m *RpcObjectIdsSubscribeRequest) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *RpcObjectIdsSubscribeRequest) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *RpcObjectIdsSubscribeRequest) GetIgnoreWorkspace() string {
	if m != nil {
		return m.IgnoreWorkspace
	}
	return ""
}

type RpcObjectIdsSubscribeResponse struct {
	Error        *RpcObjectIdsSubscribeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Records      []*types.Struct                     `protobuf:"bytes,2,rep,name=records,proto3" json:"records,omitempty"`
	Dependencies []*types.Struct                     `protobuf:"bytes,3,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	SubId        string                              `protobuf:"bytes,4,opt,name=subId,proto3" json:"subId,omitempty"`
}

func (m *RpcObjectIdsSubscribeResponse) Reset()         { *m = RpcObjectIdsSubscribeResponse{} }
func (m *RpcObjectIdsSubscribeResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectIdsSubscribeResponse) ProtoMessage()    {}
func (*RpcObjectIdsSubscribeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 12, 1}
}
func (m *RpcObjectIdsSubscribeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectIdsSubscribeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectIdsSubscribeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectIdsSubscribeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectIdsSubscribeResponse.Merge(m, src)
}
func (m *RpcObjectIdsSubscribeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectIdsSubscribeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectIdsSubscribeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectIdsSubscribeResponse proto.InternalMessageInfo

func (m *RpcObjectIdsSubscribeResponse) GetError() *RpcObjectIdsSubscribeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectIdsSubscribeResponse) GetRecords() []*types.Struct {
	if m != nil {
		return m.Records
	}
	return nil
}

func (m *RpcObjectIdsSubscribeResponse) GetDependencies() []*types.Struct {
	if m != nil {
		return m.Dependencies
	}
	return nil
}

func (m *RpcObjectIdsSubscribeResponse) GetSubId() string {
	if m != nil {
		return m.SubId
	}
	return ""
}

type RpcObjectIdsSubscribeResponseError struct {
	Code        RpcObjectIdsSubscribeResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectIdsSubscribeResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectIdsSubscribeResponseError) Reset()         { *m = RpcObjectIdsSubscribeResponseError{} }
func (m *RpcObjectIdsSubscribeResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectIdsSubscribeResponseError) ProtoMessage()    {}
func (*RpcObjectIdsSubscribeResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 12, 1, 0}
}
func (m *RpcObjectIdsSubscribeResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectIdsSubscribeResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectIdsSubscribeResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectIdsSubscribeResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectIdsSubscribeResponseError.Merge(m, src)
}
func (m *RpcObjectIdsSubscribeResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectIdsSubscribeResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectIdsSubscribeResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectIdsSubscribeResponseError proto.InternalMessageInfo

func (m *RpcObjectIdsSubscribeResponseError) GetCode() RpcObjectIdsSubscribeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectIdsSubscribeResponseError_NULL
}

func (m *RpcObjectIdsSubscribeResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectSearchUnsubscribe struct {
}

func (m *RpcObjectSearchUnsubscribe) Reset()         { *m = RpcObjectSearchUnsubscribe{} }
func (m *RpcObjectSearchUnsubscribe) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchUnsubscribe) ProtoMessage()    {}
func (*RpcObjectSearchUnsubscribe) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 13}
}
func (m *RpcObjectSearchUnsubscribe) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchUnsubscribe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchUnsubscribe.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchUnsubscribe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchUnsubscribe.Merge(m, src)
}
func (m *RpcObjectSearchUnsubscribe) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchUnsubscribe) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchUnsubscribe.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchUnsubscribe proto.InternalMessageInfo

type RpcObjectSearchUnsubscribeRequest struct {
	SubIds []string `protobuf:"bytes,1,rep,name=subIds,proto3" json:"subIds,omitempty"`
}

func (m *RpcObjectSearchUnsubscribeRequest) Reset()         { *m = RpcObjectSearchUnsubscribeRequest{} }
func (m *RpcObjectSearchUnsubscribeRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchUnsubscribeRequest) ProtoMessage()    {}
func (*RpcObjectSearchUnsubscribeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 13, 0}
}
func (m *RpcObjectSearchUnsubscribeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchUnsubscribeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchUnsubscribeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchUnsubscribeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchUnsubscribeRequest.Merge(m, src)
}
func (m *RpcObjectSearchUnsubscribeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchUnsubscribeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchUnsubscribeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchUnsubscribeRequest proto.InternalMessageInfo

func (m *RpcObjectSearchUnsubscribeRequest) GetSubIds() []string {
	if m != nil {
		return m.SubIds
	}
	return nil
}

type RpcObjectSearchUnsubscribeResponse struct {
	Error *RpcObjectSearchUnsubscribeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectSearchUnsubscribeResponse) Reset()         { *m = RpcObjectSearchUnsubscribeResponse{} }
func (m *RpcObjectSearchUnsubscribeResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchUnsubscribeResponse) ProtoMessage()    {}
func (*RpcObjectSearchUnsubscribeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 13, 1}
}
func (m *RpcObjectSearchUnsubscribeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchUnsubscribeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchUnsubscribeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchUnsubscribeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchUnsubscribeResponse.Merge(m, src)
}
func (m *RpcObjectSearchUnsubscribeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchUnsubscribeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchUnsubscribeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchUnsubscribeResponse proto.InternalMessageInfo

func (m *RpcObjectSearchUnsubscribeResponse) GetError() *RpcObjectSearchUnsubscribeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectSearchUnsubscribeResponseError struct {
	Code        RpcObjectSearchUnsubscribeResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectSearchUnsubscribeResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectSearchUnsubscribeResponseError) Reset() {
	*m = RpcObjectSearchUnsubscribeResponseError{}
}
func (m *RpcObjectSearchUnsubscribeResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSearchUnsubscribeResponseError) ProtoMessage()    {}
func (*RpcObjectSearchUnsubscribeResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 13, 1, 0}
}
func (m *RpcObjectSearchUnsubscribeResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSearchUnsubscribeResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSearchUnsubscribeResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSearchUnsubscribeResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSearchUnsubscribeResponseError.Merge(m, src)
}
func (m *RpcObjectSearchUnsubscribeResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSearchUnsubscribeResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSearchUnsubscribeResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSearchUnsubscribeResponseError proto.InternalMessageInfo

func (m *RpcObjectSearchUnsubscribeResponseError) GetCode() RpcObjectSearchUnsubscribeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSearchUnsubscribeResponseError_NULL
}

func (m *RpcObjectSearchUnsubscribeResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectSetLayout struct {
}

func (m *RpcObjectSetLayout) Reset()         { *m = RpcObjectSetLayout{} }
func (m *RpcObjectSetLayout) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetLayout) ProtoMessage()    {}
func (*RpcObjectSetLayout) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 14}
}
func (m *RpcObjectSetLayout) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetLayout) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetLayout.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetLayout) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetLayout.Merge(m, src)
}
func (m *RpcObjectSetLayout) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetLayout) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetLayout.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetLayout proto.InternalMessageInfo

type RpcObjectSetLayoutRequest struct {
	ContextId string                 `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Layout    model.ObjectTypeLayout `protobuf:"varint,3,opt,name=layout,proto3,enum=anytype.model.ObjectTypeLayout" json:"layout,omitempty"`
}

func (m *RpcObjectSetLayoutRequest) Reset()         { *m = RpcObjectSetLayoutRequest{} }
func (m *RpcObjectSetLayoutRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetLayoutRequest) ProtoMessage()    {}
func (*RpcObjectSetLayoutRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 14, 0}
}
func (m *RpcObjectSetLayoutRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetLayoutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetLayoutRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetLayoutRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetLayoutRequest.Merge(m, src)
}
func (m *RpcObjectSetLayoutRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetLayoutRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetLayoutRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetLayoutRequest proto.InternalMessageInfo

func (m *RpcObjectSetLayoutRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectSetLayoutRequest) GetLayout() model.ObjectTypeLayout {
	if m != nil {
		return m.Layout
	}
	return model.ObjectType_basic
}

type RpcObjectSetLayoutResponse struct {
	Error *RpcObjectSetLayoutResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                   `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectSetLayoutResponse) Reset()         { *m = RpcObjectSetLayoutResponse{} }
func (m *RpcObjectSetLayoutResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetLayoutResponse) ProtoMessage()    {}
func (*RpcObjectSetLayoutResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 14, 1}
}
func (m *RpcObjectSetLayoutResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetLayoutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetLayoutResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetLayoutResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetLayoutResponse.Merge(m, src)
}
func (m *RpcObjectSetLayoutResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetLayoutResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetLayoutResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetLayoutResponse proto.InternalMessageInfo

func (m *RpcObjectSetLayoutResponse) GetError() *RpcObjectSetLayoutResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetLayoutResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectSetLayoutResponseError struct {
	Code        RpcObjectSetLayoutResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectSetLayoutResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectSetLayoutResponseError) Reset()         { *m = RpcObjectSetLayoutResponseError{} }
func (m *RpcObjectSetLayoutResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetLayoutResponseError) ProtoMessage()    {}
func (*RpcObjectSetLayoutResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 14, 1, 0}
}
func (m *RpcObjectSetLayoutResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetLayoutResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetLayoutResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetLayoutResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetLayoutResponseError.Merge(m, src)
}
func (m *RpcObjectSetLayoutResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetLayoutResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetLayoutResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetLayoutResponseError proto.InternalMessageInfo

func (m *RpcObjectSetLayoutResponseError) GetCode() RpcObjectSetLayoutResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetLayoutResponseError_NULL
}

func (m *RpcObjectSetLayoutResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectSetIsFavorite struct {
}

func (m *RpcObjectSetIsFavorite) Reset()         { *m = RpcObjectSetIsFavorite{} }
func (m *RpcObjectSetIsFavorite) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsFavorite) ProtoMessage()    {}
func (*RpcObjectSetIsFavorite) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 15}
}
func (m *RpcObjectSetIsFavorite) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsFavorite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsFavorite.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsFavorite) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsFavorite.Merge(m, src)
}
func (m *RpcObjectSetIsFavorite) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsFavorite) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsFavorite.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsFavorite proto.InternalMessageInfo

type RpcObjectSetIsFavoriteRequest struct {
	ContextId  string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	IsFavorite bool   `protobuf:"varint,2,opt,name=isFavorite,proto3" json:"isFavorite,omitempty"`
}

func (m *RpcObjectSetIsFavoriteRequest) Reset()         { *m = RpcObjectSetIsFavoriteRequest{} }
func (m *RpcObjectSetIsFavoriteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsFavoriteRequest) ProtoMessage()    {}
func (*RpcObjectSetIsFavoriteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 15, 0}
}
func (m *RpcObjectSetIsFavoriteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsFavoriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsFavoriteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsFavoriteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsFavoriteRequest.Merge(m, src)
}
func (m *RpcObjectSetIsFavoriteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsFavoriteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsFavoriteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsFavoriteRequest proto.InternalMessageInfo

func (m *RpcObjectSetIsFavoriteRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectSetIsFavoriteRequest) GetIsFavorite() bool {
	if m != nil {
		return m.IsFavorite
	}
	return false
}

type RpcObjectSetIsFavoriteResponse struct {
	Error *RpcObjectSetIsFavoriteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectSetIsFavoriteResponse) Reset()         { *m = RpcObjectSetIsFavoriteResponse{} }
func (m *RpcObjectSetIsFavoriteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsFavoriteResponse) ProtoMessage()    {}
func (*RpcObjectSetIsFavoriteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 15, 1}
}
func (m *RpcObjectSetIsFavoriteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsFavoriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsFavoriteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsFavoriteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsFavoriteResponse.Merge(m, src)
}
func (m *RpcObjectSetIsFavoriteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsFavoriteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsFavoriteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsFavoriteResponse proto.InternalMessageInfo

func (m *RpcObjectSetIsFavoriteResponse) GetError() *RpcObjectSetIsFavoriteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetIsFavoriteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectSetIsFavoriteResponseError struct {
	Code        RpcObjectSetIsFavoriteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectSetIsFavoriteResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectSetIsFavoriteResponseError) Reset()         { *m = RpcObjectSetIsFavoriteResponseError{} }
func (m *RpcObjectSetIsFavoriteResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsFavoriteResponseError) ProtoMessage()    {}
func (*RpcObjectSetIsFavoriteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 15, 1, 0}
}
func (m *RpcObjectSetIsFavoriteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsFavoriteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsFavoriteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsFavoriteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsFavoriteResponseError.Merge(m, src)
}
func (m *RpcObjectSetIsFavoriteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsFavoriteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsFavoriteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsFavoriteResponseError proto.InternalMessageInfo

func (m *RpcObjectSetIsFavoriteResponseError) GetCode() RpcObjectSetIsFavoriteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetIsFavoriteResponseError_NULL
}

func (m *RpcObjectSetIsFavoriteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectSetIsArchived struct {
}

func (m *RpcObjectSetIsArchived) Reset()         { *m = RpcObjectSetIsArchived{} }
func (m *RpcObjectSetIsArchived) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsArchived) ProtoMessage()    {}
func (*RpcObjectSetIsArchived) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 16}
}
func (m *RpcObjectSetIsArchived) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsArchived) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsArchived.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsArchived) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsArchived.Merge(m, src)
}
func (m *RpcObjectSetIsArchived) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsArchived) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsArchived.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsArchived proto.InternalMessageInfo

type RpcObjectSetIsArchivedRequest struct {
	ContextId  string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	IsArchived bool   `protobuf:"varint,2,opt,name=isArchived,proto3" json:"isArchived,omitempty"`
}

func (m *RpcObjectSetIsArchivedRequest) Reset()         { *m = RpcObjectSetIsArchivedRequest{} }
func (m *RpcObjectSetIsArchivedRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsArchivedRequest) ProtoMessage()    {}
func (*RpcObjectSetIsArchivedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 16, 0}
}
func (m *RpcObjectSetIsArchivedRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsArchivedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsArchivedRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsArchivedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsArchivedRequest.Merge(m, src)
}
func (m *RpcObjectSetIsArchivedRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsArchivedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsArchivedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsArchivedRequest proto.InternalMessageInfo

func (m *RpcObjectSetIsArchivedRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectSetIsArchivedRequest) GetIsArchived() bool {
	if m != nil {
		return m.IsArchived
	}
	return false
}

type RpcObjectSetIsArchivedResponse struct {
	Error *RpcObjectSetIsArchivedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectSetIsArchivedResponse) Reset()         { *m = RpcObjectSetIsArchivedResponse{} }
func (m *RpcObjectSetIsArchivedResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsArchivedResponse) ProtoMessage()    {}
func (*RpcObjectSetIsArchivedResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 16, 1}
}
func (m *RpcObjectSetIsArchivedResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsArchivedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsArchivedResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsArchivedResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsArchivedResponse.Merge(m, src)
}
func (m *RpcObjectSetIsArchivedResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsArchivedResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsArchivedResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsArchivedResponse proto.InternalMessageInfo

func (m *RpcObjectSetIsArchivedResponse) GetError() *RpcObjectSetIsArchivedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetIsArchivedResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectSetIsArchivedResponseError struct {
	Code        RpcObjectSetIsArchivedResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectSetIsArchivedResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectSetIsArchivedResponseError) Reset()         { *m = RpcObjectSetIsArchivedResponseError{} }
func (m *RpcObjectSetIsArchivedResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetIsArchivedResponseError) ProtoMessage()    {}
func (*RpcObjectSetIsArchivedResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 16, 1, 0}
}
func (m *RpcObjectSetIsArchivedResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetIsArchivedResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetIsArchivedResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetIsArchivedResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetIsArchivedResponseError.Merge(m, src)
}
func (m *RpcObjectSetIsArchivedResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetIsArchivedResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetIsArchivedResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetIsArchivedResponseError proto.InternalMessageInfo

func (m *RpcObjectSetIsArchivedResponseError) GetCode() RpcObjectSetIsArchivedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetIsArchivedResponseError_NULL
}

func (m *RpcObjectSetIsArchivedResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectFeaturedRelation struct {
}

func (m *RpcObjectFeaturedRelation) Reset()         { *m = RpcObjectFeaturedRelation{} }
func (m *RpcObjectFeaturedRelation) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelation) ProtoMessage()    {}
func (*RpcObjectFeaturedRelation) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17}
}
func (m *RpcObjectFeaturedRelation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelation.Merge(m, src)
}
func (m *RpcObjectFeaturedRelation) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelation) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelation.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelation proto.InternalMessageInfo

type RpcObjectFeaturedRelationAdd struct {
}

func (m *RpcObjectFeaturedRelationAdd) Reset()         { *m = RpcObjectFeaturedRelationAdd{} }
func (m *RpcObjectFeaturedRelationAdd) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelationAdd) ProtoMessage()    {}
func (*RpcObjectFeaturedRelationAdd) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 0}
}
func (m *RpcObjectFeaturedRelationAdd) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationAdd.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationAdd) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationAdd.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationAdd) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationAdd) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationAdd.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationAdd proto.InternalMessageInfo

type RpcObjectFeaturedRelationAddRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Relations []string `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcObjectFeaturedRelationAddRequest) Reset()         { *m = RpcObjectFeaturedRelationAddRequest{} }
func (m *RpcObjectFeaturedRelationAddRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelationAddRequest) ProtoMessage()    {}
func (*RpcObjectFeaturedRelationAddRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 0, 0}
}
func (m *RpcObjectFeaturedRelationAddRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationAddRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationAddRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationAddRequest.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationAddRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationAddRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationAddRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationAddRequest proto.InternalMessageInfo

func (m *RpcObjectFeaturedRelationAddRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectFeaturedRelationAddRequest) GetRelations() []string {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcObjectFeaturedRelationAddResponse struct {
	Error *RpcObjectFeaturedRelationAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectFeaturedRelationAddResponse) Reset()         { *m = RpcObjectFeaturedRelationAddResponse{} }
func (m *RpcObjectFeaturedRelationAddResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelationAddResponse) ProtoMessage()    {}
func (*RpcObjectFeaturedRelationAddResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 0, 1}
}
func (m *RpcObjectFeaturedRelationAddResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationAddResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationAddResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationAddResponse.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationAddResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationAddResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationAddResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationAddResponse proto.InternalMessageInfo

func (m *RpcObjectFeaturedRelationAddResponse) GetError() *RpcObjectFeaturedRelationAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectFeaturedRelationAddResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectFeaturedRelationAddResponseError struct {
	Code        RpcObjectFeaturedRelationAddResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectFeaturedRelationAddResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectFeaturedRelationAddResponseError) Reset() {
	*m = RpcObjectFeaturedRelationAddResponseError{}
}
func (m *RpcObjectFeaturedRelationAddResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcObjectFeaturedRelationAddResponseError) ProtoMessage() {}
func (*RpcObjectFeaturedRelationAddResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 0, 1, 0}
}
func (m *RpcObjectFeaturedRelationAddResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationAddResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationAddResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationAddResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationAddResponseError.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationAddResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationAddResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationAddResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationAddResponseError proto.InternalMessageInfo

func (m *RpcObjectFeaturedRelationAddResponseError) GetCode() RpcObjectFeaturedRelationAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectFeaturedRelationAddResponseError_NULL
}

func (m *RpcObjectFeaturedRelationAddResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectFeaturedRelationRemove struct {
}

func (m *RpcObjectFeaturedRelationRemove) Reset()         { *m = RpcObjectFeaturedRelationRemove{} }
func (m *RpcObjectFeaturedRelationRemove) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelationRemove) ProtoMessage()    {}
func (*RpcObjectFeaturedRelationRemove) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 1}
}
func (m *RpcObjectFeaturedRelationRemove) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationRemove.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationRemove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationRemove.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationRemove) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationRemove) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationRemove.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationRemove proto.InternalMessageInfo

type RpcObjectFeaturedRelationRemoveRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Relations []string `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcObjectFeaturedRelationRemoveRequest) Reset() {
	*m = RpcObjectFeaturedRelationRemoveRequest{}
}
func (m *RpcObjectFeaturedRelationRemoveRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelationRemoveRequest) ProtoMessage()    {}
func (*RpcObjectFeaturedRelationRemoveRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 1, 0}
}
func (m *RpcObjectFeaturedRelationRemoveRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationRemoveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationRemoveRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationRemoveRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationRemoveRequest.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationRemoveRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationRemoveRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationRemoveRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationRemoveRequest proto.InternalMessageInfo

func (m *RpcObjectFeaturedRelationRemoveRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectFeaturedRelationRemoveRequest) GetRelations() []string {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcObjectFeaturedRelationRemoveResponse struct {
	Error *RpcObjectFeaturedRelationRemoveResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectFeaturedRelationRemoveResponse) Reset() {
	*m = RpcObjectFeaturedRelationRemoveResponse{}
}
func (m *RpcObjectFeaturedRelationRemoveResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectFeaturedRelationRemoveResponse) ProtoMessage()    {}
func (*RpcObjectFeaturedRelationRemoveResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 1, 1}
}
func (m *RpcObjectFeaturedRelationRemoveResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationRemoveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationRemoveResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponse.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationRemoveResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationRemoveResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponse proto.InternalMessageInfo

func (m *RpcObjectFeaturedRelationRemoveResponse) GetError() *RpcObjectFeaturedRelationRemoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectFeaturedRelationRemoveResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectFeaturedRelationRemoveResponseError struct {
	Code        RpcObjectFeaturedRelationRemoveResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectFeaturedRelationRemoveResponseErrorCode" json:"code,omitempty"`
	Description string                                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectFeaturedRelationRemoveResponseError) Reset() {
	*m = RpcObjectFeaturedRelationRemoveResponseError{}
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcObjectFeaturedRelationRemoveResponseError) ProtoMessage() {}
func (*RpcObjectFeaturedRelationRemoveResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 17, 1, 1, 0}
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponseError.Merge(m, src)
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectFeaturedRelationRemoveResponseError proto.InternalMessageInfo

func (m *RpcObjectFeaturedRelationRemoveResponseError) GetCode() RpcObjectFeaturedRelationRemoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectFeaturedRelationRemoveResponseError_NULL
}

func (m *RpcObjectFeaturedRelationRemoveResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectToSet struct {
}

func (m *RpcObjectToSet) Reset()         { *m = RpcObjectToSet{} }
func (m *RpcObjectToSet) String() string { return proto.CompactTextString(m) }
func (*RpcObjectToSet) ProtoMessage()    {}
func (*RpcObjectToSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 18}
}
func (m *RpcObjectToSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectToSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectToSet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectToSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectToSet.Merge(m, src)
}
func (m *RpcObjectToSet) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectToSet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectToSet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectToSet proto.InternalMessageInfo

type RpcObjectToSetRequest struct {
	ContextId string   `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Source    []string `protobuf:"bytes,2,rep,name=source,proto3" json:"source,omitempty"`
}

func (m *RpcObjectToSetRequest) Reset()         { *m = RpcObjectToSetRequest{} }
func (m *RpcObjectToSetRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectToSetRequest) ProtoMessage()    {}
func (*RpcObjectToSetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 18, 0}
}
func (m *RpcObjectToSetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectToSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectToSetRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectToSetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectToSetRequest.Merge(m, src)
}
func (m *RpcObjectToSetRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectToSetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectToSetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectToSetRequest proto.InternalMessageInfo

func (m *RpcObjectToSetRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcObjectToSetRequest) GetSource() []string {
	if m != nil {
		return m.Source
	}
	return nil
}

type RpcObjectToSetResponse struct {
	Error *RpcObjectToSetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	SetId string                       `protobuf:"bytes,2,opt,name=setId,proto3" json:"setId,omitempty"`
}

func (m *RpcObjectToSetResponse) Reset()         { *m = RpcObjectToSetResponse{} }
func (m *RpcObjectToSetResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectToSetResponse) ProtoMessage()    {}
func (*RpcObjectToSetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 18, 1}
}
func (m *RpcObjectToSetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectToSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectToSetResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectToSetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectToSetResponse.Merge(m, src)
}
func (m *RpcObjectToSetResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectToSetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectToSetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectToSetResponse proto.InternalMessageInfo

func (m *RpcObjectToSetResponse) GetError() *RpcObjectToSetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectToSetResponse) GetSetId() string {
	if m != nil {
		return m.SetId
	}
	return ""
}

type RpcObjectToSetResponseError struct {
	Code        RpcObjectToSetResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectToSetResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectToSetResponseError) Reset()         { *m = RpcObjectToSetResponseError{} }
func (m *RpcObjectToSetResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectToSetResponseError) ProtoMessage()    {}
func (*RpcObjectToSetResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 23, 18, 1, 0}
}
func (m *RpcObjectToSetResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectToSetResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectToSetResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectToSetResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectToSetResponseError.Merge(m, src)
}
func (m *RpcObjectToSetResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectToSetResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectToSetResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectToSetResponseError proto.InternalMessageInfo

func (m *RpcObjectToSetResponseError) GetCode() RpcObjectToSetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectToSetResponseError_NULL
}

func (m *RpcObjectToSetResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectList struct {
}

func (m *RpcObjectList) Reset()         { *m = RpcObjectList{} }
func (m *RpcObjectList) String() string { return proto.CompactTextString(m) }
func (*RpcObjectList) ProtoMessage()    {}
func (*RpcObjectList) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24}
}
func (m *RpcObjectList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectList.Merge(m, src)
}
func (m *RpcObjectList) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectList) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectList.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectList proto.InternalMessageInfo

type RpcObjectListDelete struct {
}

func (m *RpcObjectListDelete) Reset()         { *m = RpcObjectListDelete{} }
func (m *RpcObjectListDelete) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListDelete) ProtoMessage()    {}
func (*RpcObjectListDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0}
}
func (m *RpcObjectListDelete) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListDelete.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListDelete.Merge(m, src)
}
func (m *RpcObjectListDelete) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListDelete.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListDelete proto.InternalMessageInfo

// Deletes the object, keys from the local store and unsubscribe from remote changes. Also offloads all orphan files
type RpcObjectListDeleteRequest struct {
	ObjectIds []string `protobuf:"bytes,1,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
}

func (m *RpcObjectListDeleteRequest) Reset()         { *m = RpcObjectListDeleteRequest{} }
func (m *RpcObjectListDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListDeleteRequest) ProtoMessage()    {}
func (*RpcObjectListDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 0}
}
func (m *RpcObjectListDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListDeleteRequest.Merge(m, src)
}
func (m *RpcObjectListDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListDeleteRequest proto.InternalMessageInfo

func (m *RpcObjectListDeleteRequest) GetObjectIds() []string {
	if m != nil {
		return m.ObjectIds
	}
	return nil
}

type RpcObjectListDeleteResponse struct {
	Error *RpcObjectListDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcObjectListDeleteResponse) Reset()         { *m = RpcObjectListDeleteResponse{} }
func (m *RpcObjectListDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListDeleteResponse) ProtoMessage()    {}
func (*RpcObjectListDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 1}
}
func (m *RpcObjectListDeleteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListDeleteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListDeleteResponse.Merge(m, src)
}
func (m *RpcObjectListDeleteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListDeleteResponse proto.InternalMessageInfo

func (m *RpcObjectListDeleteResponse) GetError() *RpcObjectListDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectListDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcObjectListDeleteResponseError struct {
	Code        RpcObjectListDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectListDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectListDeleteResponseError) Reset()         { *m = RpcObjectListDeleteResponseError{} }
func (m *RpcObjectListDeleteResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListDeleteResponseError) ProtoMessage()    {}
func (*RpcObjectListDeleteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 1, 0}
}
func (m *RpcObjectListDeleteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListDeleteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListDeleteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListDeleteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListDeleteResponseError.Merge(m, src)
}
func (m *RpcObjectListDeleteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListDeleteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListDeleteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListDeleteResponseError proto.InternalMessageInfo

func (m *RpcObjectListDeleteResponseError) GetCode() RpcObjectListDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectListDeleteResponseError_NULL
}

func (m *RpcObjectListDeleteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectListSet struct {
}

func (m *RpcObjectListSet) Reset()         { *m = RpcObjectListSet{} }
func (m *RpcObjectListSet) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSet) ProtoMessage()    {}
func (*RpcObjectListSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1}
}
func (m *RpcObjectListSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSet.Merge(m, src)
}
func (m *RpcObjectListSet) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSet) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSet.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSet proto.InternalMessageInfo

type RpcObjectListSetIsArchived struct {
}

func (m *RpcObjectListSetIsArchived) Reset()         { *m = RpcObjectListSetIsArchived{} }
func (m *RpcObjectListSetIsArchived) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsArchived) ProtoMessage()    {}
func (*RpcObjectListSetIsArchived) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 0}
}
func (m *RpcObjectListSetIsArchived) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsArchived) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsArchived.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsArchived) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsArchived.Merge(m, src)
}
func (m *RpcObjectListSetIsArchived) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsArchived) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsArchived.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsArchived proto.InternalMessageInfo

type RpcObjectListSetIsArchivedRequest struct {
	ObjectIds  []string `protobuf:"bytes,1,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
	IsArchived bool     `protobuf:"varint,2,opt,name=isArchived,proto3" json:"isArchived,omitempty"`
}

func (m *RpcObjectListSetIsArchivedRequest) Reset()         { *m = RpcObjectListSetIsArchivedRequest{} }
func (m *RpcObjectListSetIsArchivedRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsArchivedRequest) ProtoMessage()    {}
func (*RpcObjectListSetIsArchivedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 0, 0}
}
func (m *RpcObjectListSetIsArchivedRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsArchivedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsArchivedRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsArchivedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsArchivedRequest.Merge(m, src)
}
func (m *RpcObjectListSetIsArchivedRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsArchivedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsArchivedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsArchivedRequest proto.InternalMessageInfo

func (m *RpcObjectListSetIsArchivedRequest) GetObjectIds() []string {
	if m != nil {
		return m.ObjectIds
	}
	return nil
}

func (m *RpcObjectListSetIsArchivedRequest) GetIsArchived() bool {
	if m != nil {
		return m.IsArchived
	}
	return false
}

type RpcObjectListSetIsArchivedResponse struct {
	Error *RpcObjectListSetIsArchivedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectListSetIsArchivedResponse) Reset()         { *m = RpcObjectListSetIsArchivedResponse{} }
func (m *RpcObjectListSetIsArchivedResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsArchivedResponse) ProtoMessage()    {}
func (*RpcObjectListSetIsArchivedResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 0, 1}
}
func (m *RpcObjectListSetIsArchivedResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsArchivedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsArchivedResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsArchivedResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsArchivedResponse.Merge(m, src)
}
func (m *RpcObjectListSetIsArchivedResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsArchivedResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsArchivedResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsArchivedResponse proto.InternalMessageInfo

func (m *RpcObjectListSetIsArchivedResponse) GetError() *RpcObjectListSetIsArchivedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectListSetIsArchivedResponseError struct {
	Code        RpcObjectListSetIsArchivedResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectListSetIsArchivedResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectListSetIsArchivedResponseError) Reset() {
	*m = RpcObjectListSetIsArchivedResponseError{}
}
func (m *RpcObjectListSetIsArchivedResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsArchivedResponseError) ProtoMessage()    {}
func (*RpcObjectListSetIsArchivedResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 0, 1, 0}
}
func (m *RpcObjectListSetIsArchivedResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsArchivedResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsArchivedResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsArchivedResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsArchivedResponseError.Merge(m, src)
}
func (m *RpcObjectListSetIsArchivedResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsArchivedResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsArchivedResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsArchivedResponseError proto.InternalMessageInfo

func (m *RpcObjectListSetIsArchivedResponseError) GetCode() RpcObjectListSetIsArchivedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectListSetIsArchivedResponseError_NULL
}

func (m *RpcObjectListSetIsArchivedResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectListSetIsFavorite struct {
}

func (m *RpcObjectListSetIsFavorite) Reset()         { *m = RpcObjectListSetIsFavorite{} }
func (m *RpcObjectListSetIsFavorite) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsFavorite) ProtoMessage()    {}
func (*RpcObjectListSetIsFavorite) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 1}
}
func (m *RpcObjectListSetIsFavorite) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsFavorite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsFavorite.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsFavorite) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsFavorite.Merge(m, src)
}
func (m *RpcObjectListSetIsFavorite) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsFavorite) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsFavorite.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsFavorite proto.InternalMessageInfo

type RpcObjectListSetIsFavoriteRequest struct {
	ObjectIds  []string `protobuf:"bytes,1,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
	IsFavorite bool     `protobuf:"varint,2,opt,name=isFavorite,proto3" json:"isFavorite,omitempty"`
}

func (m *RpcObjectListSetIsFavoriteRequest) Reset()         { *m = RpcObjectListSetIsFavoriteRequest{} }
func (m *RpcObjectListSetIsFavoriteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsFavoriteRequest) ProtoMessage()    {}
func (*RpcObjectListSetIsFavoriteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 1, 0}
}
func (m *RpcObjectListSetIsFavoriteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsFavoriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsFavoriteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsFavoriteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsFavoriteRequest.Merge(m, src)
}
func (m *RpcObjectListSetIsFavoriteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsFavoriteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsFavoriteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsFavoriteRequest proto.InternalMessageInfo

func (m *RpcObjectListSetIsFavoriteRequest) GetObjectIds() []string {
	if m != nil {
		return m.ObjectIds
	}
	return nil
}

func (m *RpcObjectListSetIsFavoriteRequest) GetIsFavorite() bool {
	if m != nil {
		return m.IsFavorite
	}
	return false
}

type RpcObjectListSetIsFavoriteResponse struct {
	Error *RpcObjectListSetIsFavoriteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcObjectListSetIsFavoriteResponse) Reset()         { *m = RpcObjectListSetIsFavoriteResponse{} }
func (m *RpcObjectListSetIsFavoriteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsFavoriteResponse) ProtoMessage()    {}
func (*RpcObjectListSetIsFavoriteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 1, 1}
}
func (m *RpcObjectListSetIsFavoriteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsFavoriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsFavoriteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsFavoriteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsFavoriteResponse.Merge(m, src)
}
func (m *RpcObjectListSetIsFavoriteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsFavoriteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsFavoriteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsFavoriteResponse proto.InternalMessageInfo

func (m *RpcObjectListSetIsFavoriteResponse) GetError() *RpcObjectListSetIsFavoriteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcObjectListSetIsFavoriteResponseError struct {
	Code        RpcObjectListSetIsFavoriteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectListSetIsFavoriteResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectListSetIsFavoriteResponseError) Reset() {
	*m = RpcObjectListSetIsFavoriteResponseError{}
}
func (m *RpcObjectListSetIsFavoriteResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListSetIsFavoriteResponseError) ProtoMessage()    {}
func (*RpcObjectListSetIsFavoriteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 1, 1, 1, 0}
}
func (m *RpcObjectListSetIsFavoriteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListSetIsFavoriteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListSetIsFavoriteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListSetIsFavoriteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListSetIsFavoriteResponseError.Merge(m, src)
}
func (m *RpcObjectListSetIsFavoriteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListSetIsFavoriteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListSetIsFavoriteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListSetIsFavoriteResponseError proto.InternalMessageInfo

func (m *RpcObjectListSetIsFavoriteResponseError) GetCode() RpcObjectListSetIsFavoriteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectListSetIsFavoriteResponseError_NULL
}

func (m *RpcObjectListSetIsFavoriteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcExport struct {
}

func (m *RpcExport) Reset()         { *m = RpcExport{} }
func (m *RpcExport) String() string { return proto.CompactTextString(m) }
func (*RpcExport) ProtoMessage()    {}
func (*RpcExport) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25}
}
func (m *RpcExport) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExport.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExport) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExport.Merge(m, src)
}
func (m *RpcExport) XXX_Size() int {
	return m.Size()
}
func (m *RpcExport) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExport.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExport proto.InternalMessageInfo

type RpcExportRequest struct {
	// the path where export files will place
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// ids of documents for export, when empty - will export all available docs
	DocIds []string `protobuf:"bytes,2,rep,name=docIds,proto3" json:"docIds,omitempty"`
	// export format
	Format RpcExportFormat `protobuf:"varint,3,opt,name=format,proto3,enum=anytype.RpcExportFormat" json:"format,omitempty"`
	// save as zip file
	Zip bool `protobuf:"varint,4,opt,name=zip,proto3" json:"zip,omitempty"`
	// include all nested
	IncludeNested bool `protobuf:"varint,5,opt,name=includeNested,proto3" json:"includeNested,omitempty"`
	// include all files
	IncludeFiles bool `protobuf:"varint,6,opt,name=includeFiles,proto3" json:"includeFiles,omitempty"`
}

func (m *RpcExportRequest) Reset()         { *m = RpcExportRequest{} }
func (m *RpcExportRequest) String() string { return proto.CompactTextString(m) }
func (*RpcExportRequest) ProtoMessage()    {}
func (*RpcExportRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 0}
}
func (m *RpcExportRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportRequest.Merge(m, src)
}
func (m *RpcExportRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportRequest proto.InternalMessageInfo

func (m *RpcExportRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportRequest) GetDocIds() []string {
	if m != nil {
		return m.DocIds
	}
	return nil
}

func (m *RpcExportRequest) GetFormat() RpcExportFormat {
	if m != nil {
		return m.Format
	}
	return RpcExport_Markdown
}

func (m *RpcExportRequest) GetZip() bool {
	if m != nil {
		return m.Zip
	}
	return false
}

func (m *RpcExportRequest) GetIncludeNested() bool {
	if m != nil {
		return m.IncludeNested
	}
	return false
}

func (m *RpcExportRequest) GetIncludeFiles() bool {
	if m != nil {
		return m.IncludeFiles
	}
	return false
}

type RpcExportResponse struct {
	Error   *RpcExportResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Path    string                  `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Succeed int32                   `protobuf:"varint,4,opt,name=succeed,proto3" json:"succeed,omitempty"`
	Event   *ResponseEvent          `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcExportResponse) Reset()         { *m = RpcExportResponse{} }
func (m *RpcExportResponse) String() string { return proto.CompactTextString(m) }
func (*RpcExportResponse) ProtoMessage()    {}
func (*RpcExportResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 1}
}
func (m *RpcExportResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportResponse.Merge(m, src)
}
func (m *RpcExportResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportResponse proto.InternalMessageInfo

func (m *RpcExportResponse) GetError() *RpcExportResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcExportResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportResponse) GetSucceed() int32 {
	if m != nil {
		return m.Succeed
	}
	return 0
}

func (m *RpcExportResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcExportResponseError struct {
	Code        RpcExportResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcExportResponseErrorCode" json:"code,omitempty"`
	Description string                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcExportResponseError) Reset()         { *m = RpcExportResponseError{} }
func (m *RpcExportResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcExportResponseError) ProtoMessage()    {}
func (*RpcExportResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 1, 0}
}
func (m *RpcExportResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportResponseError.Merge(m, src)
}
func (m *RpcExportResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportResponseError proto.InternalMessageInfo

func (m *RpcExportResponseError) GetCode() RpcExportResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcExportResponseError_NULL
}

func (m *RpcExportResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcExportWorkspace struct {
}

func (m *RpcExportWorkspace) Reset()         { *m = RpcExportWorkspace{} }
func (m *RpcExportWorkspace) String() string { return proto.CompactTextString(m) }
func (*RpcExportWorkspace) ProtoMessage()    {}
func (*RpcExportWorkspace) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26}
}
func (m *RpcExportWorkspace) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportWorkspace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportWorkspace.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportWorkspace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportWorkspace.Merge(m, src)
}
func (m *RpcExportWorkspace) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportWorkspace) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportWorkspace.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportWorkspace proto.InternalMessageInfo

type RpcExportWorkspaceRequest struct {
	// the path where export files will place
	Path        string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	WorkspaceId string `protobuf:"bytes,2,opt,name=workspaceId,proto3" json:"workspaceId,omitempty"`
}

func (m *RpcExportWorkspaceRequest) Reset()         { *m = RpcExportWorkspaceRequest{} }
func (m *RpcExportWorkspaceRequest) String() string { return proto.CompactTextString(m) }
func (*RpcExportWorkspaceRequest) ProtoMessage()    {}
func (*RpcExportWorkspaceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 0}
}
func (m *RpcExportWorkspaceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportWorkspaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportWorkspaceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportWorkspaceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportWorkspaceRequest.Merge(m, src)
}
func (m *RpcExportWorkspaceRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportWorkspaceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportWorkspaceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportWorkspaceRequest proto.InternalMessageInfo

func (m *RpcExportWorkspaceRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportWorkspaceRequest) GetWorkspaceId() string {
	if m != nil {
		return m.WorkspaceId
	}
	return ""
}

type RpcExportWorkspaceResponse struct {
	Error *RpcExportWorkspaceResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Path  string                           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Event *ResponseEvent                   `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcExportWorkspaceResponse) Reset()         { *m = RpcExportWorkspaceResponse{} }
func (m *RpcExportWorkspaceResponse) String() string { return proto.CompactTextString(m) }
func (*RpcExportWorkspaceResponse) ProtoMessage()    {}
func (*RpcExportWorkspaceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 1}
}
func (m *RpcExportWorkspaceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportWorkspaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportWorkspaceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportWorkspaceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportWorkspaceResponse.Merge(m, src)
}
func (m *RpcExportWorkspaceResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportWorkspaceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportWorkspaceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportWorkspaceResponse proto.InternalMessageInfo

func (m *RpcExportWorkspaceResponse) GetError() *RpcExportWorkspaceResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcExportWorkspaceResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportWorkspaceResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcExportWorkspaceResponseError struct {
	Code        RpcExportWorkspaceResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcExportWorkspaceResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcExportWorkspaceResponseError) Reset()         { *m = RpcExportWorkspaceResponseError{} }
func (m *RpcExportWorkspaceResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcExportWorkspaceResponseError) ProtoMessage()    {}
func (*RpcExportWorkspaceResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 1, 0}
}
func (m *RpcExportWorkspaceResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportWorkspaceResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportWorkspaceResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportWorkspaceResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportWorkspaceResponseError.Merge(m, src)
}
func (m *RpcExportWorkspaceResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportWorkspaceResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportWorkspaceResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportWorkspaceResponseError proto.InternalMessageInfo

func (m *RpcExportWorkspaceResponseError) GetCode() RpcExportWorkspaceResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcExportWorkspaceResponseError_NULL
}

func (m *RpcExportWorkspaceResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcExportTemplates struct {
}

func (m *RpcExportTemplates) Reset()         { *m = RpcExportTemplates{} }
func (m *RpcExportTemplates) String() string { return proto.CompactTextString(m) }
func (*RpcExportTemplates) ProtoMessage()    {}
func (*RpcExportTemplates) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 27}
}
func (m *RpcExportTemplates) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportTemplates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportTemplates.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportTemplates) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportTemplates.Merge(m, src)
}
func (m *RpcExportTemplates) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportTemplates) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportTemplates.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportTemplates proto.InternalMessageInfo

type RpcExportTemplatesRequest struct {
	// the path where export files will place
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
}

func (m *RpcExportTemplatesRequest) Reset()         { *m = RpcExportTemplatesRequest{} }
func (m *RpcExportTemplatesRequest) String() string { return proto.CompactTextString(m) }
func (*RpcExportTemplatesRequest) ProtoMessage()    {}
func (*RpcExportTemplatesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 27, 0}
}
func (m *RpcExportTemplatesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportTemplatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportTemplatesRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportTemplatesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportTemplatesRequest.Merge(m, src)
}
func (m *RpcExportTemplatesRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportTemplatesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportTemplatesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportTemplatesRequest proto.InternalMessageInfo

func (m *RpcExportTemplatesRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type RpcExportTemplatesResponse struct {
	Error *RpcExportTemplatesResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Path  string                           `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Event *ResponseEvent                   `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcExportTemplatesResponse) Reset()         { *m = RpcExportTemplatesResponse{} }
func (m *RpcExportTemplatesResponse) String() string { return proto.CompactTextString(m) }
func (*RpcExportTemplatesResponse) ProtoMessage()    {}
func (*RpcExportTemplatesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 27, 1}
}
func (m *RpcExportTemplatesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportTemplatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportTemplatesResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportTemplatesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportTemplatesResponse.Merge(m, src)
}
func (m *RpcExportTemplatesResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportTemplatesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportTemplatesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportTemplatesResponse proto.InternalMessageInfo

func (m *RpcExportTemplatesResponse) GetError() *RpcExportTemplatesResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcExportTemplatesResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportTemplatesResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcExportTemplatesResponseError struct {
	Code        RpcExportTemplatesResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcExportTemplatesResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcExportTemplatesResponseError) Reset()         { *m = RpcExportTemplatesResponseError{} }
func (m *RpcExportTemplatesResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcExportTemplatesResponseError) ProtoMessage()    {}
func (*RpcExportTemplatesResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 27, 1, 0}
}
func (m *RpcExportTemplatesResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportTemplatesResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportTemplatesResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportTemplatesResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportTemplatesResponseError.Merge(m, src)
}
func (m *RpcExportTemplatesResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportTemplatesResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportTemplatesResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportTemplatesResponseError proto.InternalMessageInfo

func (m *RpcExportTemplatesResponseError) GetCode() RpcExportTemplatesResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcExportTemplatesResponseError_NULL
}

func (m *RpcExportTemplatesResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcExportLocalstore struct {
}

func (m *RpcExportLocalstore) Reset()         { *m = RpcExportLocalstore{} }
func (m *RpcExportLocalstore) String() string { return proto.CompactTextString(m) }
func (*RpcExportLocalstore) ProtoMessage()    {}
func (*RpcExportLocalstore) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 28}
}
func (m *RpcExportLocalstore) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportLocalstore) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportLocalstore.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportLocalstore) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportLocalstore.Merge(m, src)
}
func (m *RpcExportLocalstore) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportLocalstore) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportLocalstore.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportLocalstore proto.InternalMessageInfo

type RpcExportLocalstoreRequest struct {
	// the path where export files will place
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// ids of documents for export, when empty - will export all available docs
	DocIds []string `protobuf:"bytes,2,rep,name=docIds,proto3" json:"docIds,omitempty"`
}

func (m *RpcExportLocalstoreRequest) Reset()         { *m = RpcExportLocalstoreRequest{} }
func (m *RpcExportLocalstoreRequest) String() string { return proto.CompactTextString(m) }
func (*RpcExportLocalstoreRequest) ProtoMessage()    {}
func (*RpcExportLocalstoreRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 28, 0}
}
func (m *RpcExportLocalstoreRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportLocalstoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportLocalstoreRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportLocalstoreRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportLocalstoreRequest.Merge(m, src)
}
func (m *RpcExportLocalstoreRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportLocalstoreRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportLocalstoreRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportLocalstoreRequest proto.InternalMessageInfo

func (m *RpcExportLocalstoreRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportLocalstoreRequest) GetDocIds() []string {
	if m != nil {
		return m.DocIds
	}
	return nil
}

type RpcExportLocalstoreResponse struct {
	Error *RpcExportLocalstoreResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Path  string                            `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcExportLocalstoreResponse) Reset()         { *m = RpcExportLocalstoreResponse{} }
func (m *RpcExportLocalstoreResponse) String() string { return proto.CompactTextString(m) }
func (*RpcExportLocalstoreResponse) ProtoMessage()    {}
func (*RpcExportLocalstoreResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 28, 1}
}
func (m *RpcExportLocalstoreResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportLocalstoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportLocalstoreResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportLocalstoreResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportLocalstoreResponse.Merge(m, src)
}
func (m *RpcExportLocalstoreResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportLocalstoreResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportLocalstoreResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportLocalstoreResponse proto.InternalMessageInfo

func (m *RpcExportLocalstoreResponse) GetError() *RpcExportLocalstoreResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcExportLocalstoreResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcExportLocalstoreResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcExportLocalstoreResponseError struct {
	Code        RpcExportLocalstoreResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcExportLocalstoreResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcExportLocalstoreResponseError) Reset()         { *m = RpcExportLocalstoreResponseError{} }
func (m *RpcExportLocalstoreResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcExportLocalstoreResponseError) ProtoMessage()    {}
func (*RpcExportLocalstoreResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 28, 1, 0}
}
func (m *RpcExportLocalstoreResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcExportLocalstoreResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcExportLocalstoreResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcExportLocalstoreResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcExportLocalstoreResponseError.Merge(m, src)
}
func (m *RpcExportLocalstoreResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcExportLocalstoreResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcExportLocalstoreResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcExportLocalstoreResponseError proto.InternalMessageInfo

func (m *RpcExportLocalstoreResponseError) GetCode() RpcExportLocalstoreResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcExportLocalstoreResponseError_NULL
}

func (m *RpcExportLocalstoreResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcMakeTemplate struct {
}

func (m *RpcMakeTemplate) Reset()         { *m = RpcMakeTemplate{} }
func (m *RpcMakeTemplate) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplate) ProtoMessage()    {}
func (*RpcMakeTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 29}
}
func (m *RpcMakeTemplate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplate.Merge(m, src)
}
func (m *RpcMakeTemplate) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplate proto.InternalMessageInfo

type RpcMakeTemplateRequest struct {
	// id of block for making them template
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

func (m *RpcMakeTemplateRequest) Reset()         { *m = RpcMakeTemplateRequest{} }
func (m *RpcMakeTemplateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateRequest) ProtoMessage()    {}
func (*RpcMakeTemplateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 29, 0}
}
func (m *RpcMakeTemplateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateRequest.Merge(m, src)
}
func (m *RpcMakeTemplateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateRequest proto.InternalMessageInfo

func (m *RpcMakeTemplateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

type RpcMakeTemplateResponse struct {
	Error *RpcMakeTemplateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// created template id
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RpcMakeTemplateResponse) Reset()         { *m = RpcMakeTemplateResponse{} }
func (m *RpcMakeTemplateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateResponse) ProtoMessage()    {}
func (*RpcMakeTemplateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 29, 1}
}
func (m *RpcMakeTemplateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateResponse.Merge(m, src)
}
func (m *RpcMakeTemplateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateResponse proto.InternalMessageInfo

func (m *RpcMakeTemplateResponse) GetError() *RpcMakeTemplateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcMakeTemplateResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type RpcMakeTemplateResponseError struct {
	Code        RpcMakeTemplateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcMakeTemplateResponseErrorCode" json:"code,omitempty"`
	Description string                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcMakeTemplateResponseError) Reset()         { *m = RpcMakeTemplateResponseError{} }
func (m *RpcMakeTemplateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateResponseError) ProtoMessage()    {}
func (*RpcMakeTemplateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 29, 1, 0}
}
func (m *RpcMakeTemplateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateResponseError.Merge(m, src)
}
func (m *RpcMakeTemplateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateResponseError proto.InternalMessageInfo

func (m *RpcMakeTemplateResponseError) GetCode() RpcMakeTemplateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcMakeTemplateResponseError_NULL
}

func (m *RpcMakeTemplateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcMakeTemplateByObjectType struct {
}

func (m *RpcMakeTemplateByObjectType) Reset()         { *m = RpcMakeTemplateByObjectType{} }
func (m *RpcMakeTemplateByObjectType) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateByObjectType) ProtoMessage()    {}
func (*RpcMakeTemplateByObjectType) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 30}
}
func (m *RpcMakeTemplateByObjectType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateByObjectType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateByObjectType.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateByObjectType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateByObjectType.Merge(m, src)
}
func (m *RpcMakeTemplateByObjectType) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateByObjectType) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateByObjectType.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateByObjectType proto.InternalMessageInfo

type RpcMakeTemplateByObjectTypeRequest struct {
	// id of desired object type
	ObjectType string `protobuf:"bytes,1,opt,name=objectType,proto3" json:"objectType,omitempty"`
}

func (m *RpcMakeTemplateByObjectTypeRequest) Reset()         { *m = RpcMakeTemplateByObjectTypeRequest{} }
func (m *RpcMakeTemplateByObjectTypeRequest) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateByObjectTypeRequest) ProtoMessage()    {}
func (*RpcMakeTemplateByObjectTypeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 30, 0}
}
func (m *RpcMakeTemplateByObjectTypeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateByObjectTypeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateByObjectTypeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateByObjectTypeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateByObjectTypeRequest.Merge(m, src)
}
func (m *RpcMakeTemplateByObjectTypeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateByObjectTypeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateByObjectTypeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateByObjectTypeRequest proto.InternalMessageInfo

func (m *RpcMakeTemplateByObjectTypeRequest) GetObjectType() string {
	if m != nil {
		return m.ObjectType
	}
	return ""
}

type RpcMakeTemplateByObjectTypeResponse struct {
	Error *RpcMakeTemplateByObjectTypeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// created template id
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RpcMakeTemplateByObjectTypeResponse) Reset()         { *m = RpcMakeTemplateByObjectTypeResponse{} }
func (m *RpcMakeTemplateByObjectTypeResponse) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateByObjectTypeResponse) ProtoMessage()    {}
func (*RpcMakeTemplateByObjectTypeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 30, 1}
}
func (m *RpcMakeTemplateByObjectTypeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateByObjectTypeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateByObjectTypeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateByObjectTypeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateByObjectTypeResponse.Merge(m, src)
}
func (m *RpcMakeTemplateByObjectTypeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateByObjectTypeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateByObjectTypeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateByObjectTypeResponse proto.InternalMessageInfo

func (m *RpcMakeTemplateByObjectTypeResponse) GetError() *RpcMakeTemplateByObjectTypeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcMakeTemplateByObjectTypeResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type RpcMakeTemplateByObjectTypeResponseError struct {
	Code        RpcMakeTemplateByObjectTypeResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcMakeTemplateByObjectTypeResponseErrorCode" json:"code,omitempty"`
	Description string                                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcMakeTemplateByObjectTypeResponseError) Reset() {
	*m = RpcMakeTemplateByObjectTypeResponseError{}
}
func (m *RpcMakeTemplateByObjectTypeResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcMakeTemplateByObjectTypeResponseError) ProtoMessage()    {}
func (*RpcMakeTemplateByObjectTypeResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 30, 1, 0}
}
func (m *RpcMakeTemplateByObjectTypeResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcMakeTemplateByObjectTypeResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcMakeTemplateByObjectTypeResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcMakeTemplateByObjectTypeResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcMakeTemplateByObjectTypeResponseError.Merge(m, src)
}
func (m *RpcMakeTemplateByObjectTypeResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcMakeTemplateByObjectTypeResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcMakeTemplateByObjectTypeResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcMakeTemplateByObjectTypeResponseError proto.InternalMessageInfo

func (m *RpcMakeTemplateByObjectTypeResponseError) GetCode() RpcMakeTemplateByObjectTypeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcMakeTemplateByObjectTypeResponseError_NULL
}

func (m *RpcMakeTemplateByObjectTypeResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcCloneTemplate struct {
}

func (m *RpcCloneTemplate) Reset()         { *m = RpcCloneTemplate{} }
func (m *RpcCloneTemplate) String() string { return proto.CompactTextString(m) }
func (*RpcCloneTemplate) ProtoMessage()    {}
func (*RpcCloneTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 31}
}
func (m *RpcCloneTemplate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcCloneTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcCloneTemplate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcCloneTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcCloneTemplate.Merge(m, src)
}
func (m *RpcCloneTemplate) XXX_Size() int {
	return m.Size()
}
func (m *RpcCloneTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcCloneTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcCloneTemplate proto.InternalMessageInfo

type RpcCloneTemplateRequest struct {
	// id of template block for cloning
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

func (m *RpcCloneTemplateRequest) Reset()         { *m = RpcCloneTemplateRequest{} }
func (m *RpcCloneTemplateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcCloneTemplateRequest) ProtoMessage()    {}
func (*RpcCloneTemplateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 31, 0}
}
func (m *RpcCloneTemplateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcCloneTemplateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcCloneTemplateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcCloneTemplateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcCloneTemplateRequest.Merge(m, src)
}
func (m *RpcCloneTemplateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcCloneTemplateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcCloneTemplateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcCloneTemplateRequest proto.InternalMessageInfo

func (m *RpcCloneTemplateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

type RpcCloneTemplateResponse struct {
	Error *RpcCloneTemplateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// created template id
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RpcCloneTemplateResponse) Reset()         { *m = RpcCloneTemplateResponse{} }
func (m *RpcCloneTemplateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcCloneTemplateResponse) ProtoMessage()    {}
func (*RpcCloneTemplateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 31, 1}
}
func (m *RpcCloneTemplateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcCloneTemplateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcCloneTemplateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcCloneTemplateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcCloneTemplateResponse.Merge(m, src)
}
func (m *RpcCloneTemplateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcCloneTemplateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcCloneTemplateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcCloneTemplateResponse proto.InternalMessageInfo

func (m *RpcCloneTemplateResponse) GetError() *RpcCloneTemplateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcCloneTemplateResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type RpcCloneTemplateResponseError struct {
	Code        RpcCloneTemplateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcCloneTemplateResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcCloneTemplateResponseError) Reset()         { *m = RpcCloneTemplateResponseError{} }
func (m *RpcCloneTemplateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcCloneTemplateResponseError) ProtoMessage()    {}
func (*RpcCloneTemplateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 31, 1, 0}
}
func (m *RpcCloneTemplateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcCloneTemplateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcCloneTemplateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcCloneTemplateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcCloneTemplateResponseError.Merge(m, src)
}
func (m *RpcCloneTemplateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcCloneTemplateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcCloneTemplateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcCloneTemplateResponseError proto.InternalMessageInfo

func (m *RpcCloneTemplateResponseError) GetCode() RpcCloneTemplateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcCloneTemplateResponseError_NULL
}

func (m *RpcCloneTemplateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcObjectDuplicate struct {
}

func (m *RpcObjectDuplicate) Reset()         { *m = RpcObjectDuplicate{} }
func (m *RpcObjectDuplicate) String() string { return proto.CompactTextString(m) }
func (*RpcObjectDuplicate) ProtoMessage()    {}
func (*RpcObjectDuplicate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 32}
}
func (m *RpcObjectDuplicate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectDuplicate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectDuplicate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectDuplicate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectDuplicate.Merge(m, src)
}
func (m *RpcObjectDuplicate) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectDuplicate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectDuplicate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectDuplicate proto.InternalMessageInfo

type RpcObjectDuplicateRequest struct {
	// id of template block for cloning
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

func (m *RpcObjectDuplicateRequest) Reset()         { *m = RpcObjectDuplicateRequest{} }
func (m *RpcObjectDuplicateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectDuplicateRequest) ProtoMessage()    {}
func (*RpcObjectDuplicateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 32, 0}
}
func (m *RpcObjectDuplicateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectDuplicateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectDuplicateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectDuplicateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectDuplicateRequest.Merge(m, src)
}
func (m *RpcObjectDuplicateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectDuplicateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectDuplicateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectDuplicateRequest proto.InternalMessageInfo

func (m *RpcObjectDuplicateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

type RpcObjectDuplicateResponse struct {
	Error *RpcObjectDuplicateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// created template id
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RpcObjectDuplicateResponse) Reset()         { *m = RpcObjectDuplicateResponse{} }
func (m *RpcObjectDuplicateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectDuplicateResponse) ProtoMessage()    {}
func (*RpcObjectDuplicateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 32, 1}
}
func (m *RpcObjectDuplicateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectDuplicateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectDuplicateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectDuplicateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectDuplicateResponse.Merge(m, src)
}
func (m *RpcObjectDuplicateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectDuplicateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectDuplicateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectDuplicateResponse proto.InternalMessageInfo

func (m *RpcObjectDuplicateResponse) GetError() *RpcObjectDuplicateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectDuplicateResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type RpcObjectDuplicateResponseError struct {
	Code        RpcObjectDuplicateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcObjectDuplicateResponseErrorCode" json:"code,omitempty"`
	Description string                              `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcObjectDuplicateResponseError) Reset()         { *m = RpcObjectDuplicateResponseError{} }
func (m *RpcObjectDuplicateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcObjectDuplicateResponseError) ProtoMessage()    {}
func (*RpcObjectDuplicateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 32, 1, 0}
}
func (m *RpcObjectDuplicateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectDuplicateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectDuplicateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectDuplicateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectDuplicateResponseError.Merge(m, src)
}
func (m *RpcObjectDuplicateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectDuplicateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectDuplicateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectDuplicateResponseError proto.InternalMessageInfo

func (m *RpcObjectDuplicateResponseError) GetCode() RpcObjectDuplicateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectDuplicateResponseError_NULL
}

func (m *RpcObjectDuplicateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcUnsplashSearch struct {
}

func (m *RpcUnsplashSearch) Reset()         { *m = RpcUnsplashSearch{} }
func (m *RpcUnsplashSearch) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashSearch) ProtoMessage()    {}
func (*RpcUnsplashSearch) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 33}
}
func (m *RpcUnsplashSearch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashSearch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashSearch.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashSearch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashSearch.Merge(m, src)
}
func (m *RpcUnsplashSearch) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashSearch) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashSearch.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashSearch proto.InternalMessageInfo

type RpcUnsplashSearchRequest struct {
	Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	Limit int32  `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
}

func (m *RpcUnsplashSearchRequest) Reset()         { *m = RpcUnsplashSearchRequest{} }
func (m *RpcUnsplashSearchRequest) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashSearchRequest) ProtoMessage()    {}
func (*RpcUnsplashSearchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 33, 0}
}
func (m *RpcUnsplashSearchRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashSearchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashSearchRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashSearchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashSearchRequest.Merge(m, src)
}
func (m *RpcUnsplashSearchRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashSearchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashSearchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashSearchRequest proto.InternalMessageInfo

func (m *RpcUnsplashSearchRequest) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

func (m *RpcUnsplashSearchRequest) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

type RpcUnsplashSearchResponse struct {
	Error    *RpcUnsplashSearchResponseError     `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Pictures []*RpcUnsplashSearchResponsePicture `protobuf:"bytes,2,rep,name=pictures,proto3" json:"pictures,omitempty"`
}

func (m *RpcUnsplashSearchResponse) Reset()         { *m = RpcUnsplashSearchResponse{} }
func (m *RpcUnsplashSearchResponse) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashSearchResponse) ProtoMessage()    {}
func (*RpcUnsplashSearchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 33, 1}
}
func (m *RpcUnsplashSearchResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashSearchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashSearchResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashSearchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashSearchResponse.Merge(m, src)
}
func (m *RpcUnsplashSearchResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashSearchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashSearchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashSearchResponse proto.InternalMessageInfo

func (m *RpcUnsplashSearchResponse) GetError() *RpcUnsplashSearchResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcUnsplashSearchResponse) GetPictures() []*RpcUnsplashSearchResponsePicture {
	if m != nil {
		return m.Pictures
	}
	return nil
}

type RpcUnsplashSearchResponsePicture struct {
	Id        string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Url       string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	Artist    string `protobuf:"bytes,3,opt,name=artist,proto3" json:"artist,omitempty"`
	ArtistUrl string `protobuf:"bytes,4,opt,name=artistUrl,proto3" json:"artistUrl,omitempty"`
}

func (m *RpcUnsplashSearchResponsePicture) Reset()         { *m = RpcUnsplashSearchResponsePicture{} }
func (m *RpcUnsplashSearchResponsePicture) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashSearchResponsePicture) ProtoMessage()    {}
func (*RpcUnsplashSearchResponsePicture) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 33, 1, 0}
}
func (m *RpcUnsplashSearchResponsePicture) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashSearchResponsePicture) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashSearchResponsePicture.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashSearchResponsePicture) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashSearchResponsePicture.Merge(m, src)
}
func (m *RpcUnsplashSearchResponsePicture) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashSearchResponsePicture) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashSearchResponsePicture.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashSearchResponsePicture proto.InternalMessageInfo

func (m *RpcUnsplashSearchResponsePicture) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcUnsplashSearchResponsePicture) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *RpcUnsplashSearchResponsePicture) GetArtist() string {
	if m != nil {
		return m.Artist
	}
	return ""
}

func (m *RpcUnsplashSearchResponsePicture) GetArtistUrl() string {
	if m != nil {
		return m.ArtistUrl
	}
	return ""
}

type RpcUnsplashSearchResponseError struct {
	Code        RpcUnsplashSearchResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcUnsplashSearchResponseErrorCode" json:"code,omitempty"`
	Description string                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcUnsplashSearchResponseError) Reset()         { *m = RpcUnsplashSearchResponseError{} }
func (m *RpcUnsplashSearchResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashSearchResponseError) ProtoMessage()    {}
func (*RpcUnsplashSearchResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 33, 1, 1}
}
func (m *RpcUnsplashSearchResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashSearchResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashSearchResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashSearchResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashSearchResponseError.Merge(m, src)
}
func (m *RpcUnsplashSearchResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashSearchResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashSearchResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashSearchResponseError proto.InternalMessageInfo

func (m *RpcUnsplashSearchResponseError) GetCode() RpcUnsplashSearchResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcUnsplashSearchResponseError_NULL
}

func (m *RpcUnsplashSearchResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcUnsplashDownload struct {
}

func (m *RpcUnsplashDownload) Reset()         { *m = RpcUnsplashDownload{} }
func (m *RpcUnsplashDownload) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashDownload) ProtoMessage()    {}
func (*RpcUnsplashDownload) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 34}
}
func (m *RpcUnsplashDownload) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashDownload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashDownload.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashDownload) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashDownload.Merge(m, src)
}
func (m *RpcUnsplashDownload) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashDownload) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashDownload.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashDownload proto.InternalMessageInfo

type RpcUnsplashDownloadRequest struct {
	PictureId string `protobuf:"bytes,1,opt,name=pictureId,proto3" json:"pictureId,omitempty"`
}

func (m *RpcUnsplashDownloadRequest) Reset()         { *m = RpcUnsplashDownloadRequest{} }
func (m *RpcUnsplashDownloadRequest) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashDownloadRequest) ProtoMessage()    {}
func (*RpcUnsplashDownloadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 34, 0}
}
func (m *RpcUnsplashDownloadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashDownloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashDownloadRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashDownloadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashDownloadRequest.Merge(m, src)
}
func (m *RpcUnsplashDownloadRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashDownloadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashDownloadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashDownloadRequest proto.InternalMessageInfo

func (m *RpcUnsplashDownloadRequest) GetPictureId() string {
	if m != nil {
		return m.PictureId
	}
	return ""
}

type RpcUnsplashDownloadResponse struct {
	Error *RpcUnsplashDownloadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Hash  string                            `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *RpcUnsplashDownloadResponse) Reset()         { *m = RpcUnsplashDownloadResponse{} }
func (m *RpcUnsplashDownloadResponse) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashDownloadResponse) ProtoMessage()    {}
func (*RpcUnsplashDownloadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 34, 1}
}
func (m *RpcUnsplashDownloadResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashDownloadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashDownloadResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashDownloadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashDownloadResponse.Merge(m, src)
}
func (m *RpcUnsplashDownloadResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashDownloadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashDownloadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashDownloadResponse proto.InternalMessageInfo

func (m *RpcUnsplashDownloadResponse) GetError() *RpcUnsplashDownloadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcUnsplashDownloadResponse) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

type RpcUnsplashDownloadResponseError struct {
	Code        RpcUnsplashDownloadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcUnsplashDownloadResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcUnsplashDownloadResponseError) Reset()         { *m = RpcUnsplashDownloadResponseError{} }
func (m *RpcUnsplashDownloadResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcUnsplashDownloadResponseError) ProtoMessage()    {}
func (*RpcUnsplashDownloadResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 34, 1, 0}
}
func (m *RpcUnsplashDownloadResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcUnsplashDownloadResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcUnsplashDownloadResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcUnsplashDownloadResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcUnsplashDownloadResponseError.Merge(m, src)
}
func (m *RpcUnsplashDownloadResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcUnsplashDownloadResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcUnsplashDownloadResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcUnsplashDownloadResponseError proto.InternalMessageInfo

func (m *RpcUnsplashDownloadResponseError) GetCode() RpcUnsplashDownloadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcUnsplashDownloadResponseError_NULL
}

func (m *RpcUnsplashDownloadResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcApplyTemplate struct {
}

func (m *RpcApplyTemplate) Reset()         { *m = RpcApplyTemplate{} }
func (m *RpcApplyTemplate) String() string { return proto.CompactTextString(m) }
func (*RpcApplyTemplate) ProtoMessage()    {}
func (*RpcApplyTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 35}
}
func (m *RpcApplyTemplate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcApplyTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcApplyTemplate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcApplyTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcApplyTemplate.Merge(m, src)
}
func (m *RpcApplyTemplate) XXX_Size() int {
	return m.Size()
}
func (m *RpcApplyTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcApplyTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcApplyTemplate proto.InternalMessageInfo

type RpcApplyTemplateRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	// id of template
	TemplateId string `protobuf:"bytes,2,opt,name=templateId,proto3" json:"templateId,omitempty"`
}

func (m *RpcApplyTemplateRequest) Reset()         { *m = RpcApplyTemplateRequest{} }
func (m *RpcApplyTemplateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcApplyTemplateRequest) ProtoMessage()    {}
func (*RpcApplyTemplateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 35, 0}
}
func (m *RpcApplyTemplateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcApplyTemplateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcApplyTemplateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcApplyTemplateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcApplyTemplateRequest.Merge(m, src)
}
func (m *RpcApplyTemplateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcApplyTemplateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcApplyTemplateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcApplyTemplateRequest proto.InternalMessageInfo

func (m *RpcApplyTemplateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcApplyTemplateRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

type RpcApplyTemplateResponse struct {
	Error *RpcApplyTemplateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcApplyTemplateResponse) Reset()         { *m = RpcApplyTemplateResponse{} }
func (m *RpcApplyTemplateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcApplyTemplateResponse) ProtoMessage()    {}
func (*RpcApplyTemplateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 35, 1}
}
func (m *RpcApplyTemplateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcApplyTemplateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcApplyTemplateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcApplyTemplateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcApplyTemplateResponse.Merge(m, src)
}
func (m *RpcApplyTemplateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcApplyTemplateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcApplyTemplateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcApplyTemplateResponse proto.InternalMessageInfo

func (m *RpcApplyTemplateResponse) GetError() *RpcApplyTemplateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcApplyTemplateResponseError struct {
	Code        RpcApplyTemplateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcApplyTemplateResponseErrorCode" json:"code,omitempty"`
	Description string                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcApplyTemplateResponseError) Reset()         { *m = RpcApplyTemplateResponseError{} }
func (m *RpcApplyTemplateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcApplyTemplateResponseError) ProtoMessage()    {}
func (*RpcApplyTemplateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 35, 1, 0}
}
func (m *RpcApplyTemplateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcApplyTemplateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcApplyTemplateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcApplyTemplateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcApplyTemplateResponseError.Merge(m, src)
}
func (m *RpcApplyTemplateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcApplyTemplateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcApplyTemplateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcApplyTemplateResponseError proto.InternalMessageInfo

func (m *RpcApplyTemplateResponseError) GetCode() RpcApplyTemplateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcApplyTemplateResponseError_NULL
}

func (m *RpcApplyTemplateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcDebug struct {
}

func (m *RpcDebug) Reset()         { *m = RpcDebug{} }
func (m *RpcDebug) String() string { return proto.CompactTextString(m) }
func (*RpcDebug) ProtoMessage()    {}
func (*RpcDebug) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36}
}
func (m *RpcDebug) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebug) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebug.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebug) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebug.Merge(m, src)
}
func (m *RpcDebug) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebug) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebug.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebug proto.InternalMessageInfo

type RpcDebuglogInfo struct {
	Id             string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Head           string `protobuf:"bytes,2,opt,name=head,proto3" json:"head,omitempty"`
	HeadDownloaded bool   `protobuf:"varint,3,opt,name=headDownloaded,proto3" json:"headDownloaded,omitempty"`
	TotalRecords   int32  `protobuf:"varint,4,opt,name=totalRecords,proto3" json:"totalRecords,omitempty"`
	TotalSize      int32  `protobuf:"varint,5,opt,name=totalSize,proto3" json:"totalSize,omitempty"`
	FirstRecordTs  int32  `protobuf:"varint,6,opt,name=firstRecordTs,proto3" json:"firstRecordTs,omitempty"`
	FirstRecordVer int32  `protobuf:"varint,7,opt,name=firstRecordVer,proto3" json:"firstRecordVer,omitempty"`
	LastRecordTs   int32  `protobuf:"varint,8,opt,name=lastRecordTs,proto3" json:"lastRecordTs,omitempty"`
	LastRecordVer  int32  `protobuf:"varint,9,opt,name=lastRecordVer,proto3" json:"lastRecordVer,omitempty"`
	LastPullSecAgo int32  `protobuf:"varint,10,opt,name=lastPullSecAgo,proto3" json:"lastPullSecAgo,omitempty"`
	UpStatus       string `protobuf:"bytes,11,opt,name=upStatus,proto3" json:"upStatus,omitempty"`
	DownStatus     string `protobuf:"bytes,12,opt,name=downStatus,proto3" json:"downStatus,omitempty"`
	Error          string `protobuf:"bytes,13,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcDebuglogInfo) Reset()         { *m = RpcDebuglogInfo{} }
func (m *RpcDebuglogInfo) String() string { return proto.CompactTextString(m) }
func (*RpcDebuglogInfo) ProtoMessage()    {}
func (*RpcDebuglogInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 0}
}
func (m *RpcDebuglogInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebuglogInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebuglogInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebuglogInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebuglogInfo.Merge(m, src)
}
func (m *RpcDebuglogInfo) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebuglogInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebuglogInfo.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebuglogInfo proto.InternalMessageInfo

func (m *RpcDebuglogInfo) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcDebuglogInfo) GetHead() string {
	if m != nil {
		return m.Head
	}
	return ""
}

func (m *RpcDebuglogInfo) GetHeadDownloaded() bool {
	if m != nil {
		return m.HeadDownloaded
	}
	return false
}

func (m *RpcDebuglogInfo) GetTotalRecords() int32 {
	if m != nil {
		return m.TotalRecords
	}
	return 0
}

func (m *RpcDebuglogInfo) GetTotalSize() int32 {
	if m != nil {
		return m.TotalSize
	}
	return 0
}

func (m *RpcDebuglogInfo) GetFirstRecordTs() int32 {
	if m != nil {
		return m.FirstRecordTs
	}
	return 0
}

func (m *RpcDebuglogInfo) GetFirstRecordVer() int32 {
	if m != nil {
		return m.FirstRecordVer
	}
	return 0
}

func (m *RpcDebuglogInfo) GetLastRecordTs() int32 {
	if m != nil {
		return m.LastRecordTs
	}
	return 0
}

func (m *RpcDebuglogInfo) GetLastRecordVer() int32 {
	if m != nil {
		return m.LastRecordVer
	}
	return 0
}

func (m *RpcDebuglogInfo) GetLastPullSecAgo() int32 {
	if m != nil {
		return m.LastPullSecAgo
	}
	return 0
}

func (m *RpcDebuglogInfo) GetUpStatus() string {
	if m != nil {
		return m.UpStatus
	}
	return ""
}

func (m *RpcDebuglogInfo) GetDownStatus() string {
	if m != nil {
		return m.DownStatus
	}
	return ""
}

func (m *RpcDebuglogInfo) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type RpcDebugthreadInfo struct {
	Id                          string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	LogsWithDownloadedHead      int32              `protobuf:"varint,2,opt,name=logsWithDownloadedHead,proto3" json:"logsWithDownloadedHead,omitempty"`
	LogsWithWholeTreeDownloaded int32              `protobuf:"varint,3,opt,name=logsWithWholeTreeDownloaded,proto3" json:"logsWithWholeTreeDownloaded,omitempty"`
	Logs                        []*RpcDebuglogInfo `protobuf:"bytes,4,rep,name=logs,proto3" json:"logs,omitempty"`
	OwnLogHasCafeReplicator     bool               `protobuf:"varint,5,opt,name=ownLogHasCafeReplicator,proto3" json:"ownLogHasCafeReplicator,omitempty"`
	CafeLastPullSecAgo          int32              `protobuf:"varint,6,opt,name=cafeLastPullSecAgo,proto3" json:"cafeLastPullSecAgo,omitempty"`
	CafeUpStatus                string             `protobuf:"bytes,7,opt,name=cafeUpStatus,proto3" json:"cafeUpStatus,omitempty"`
	CafeDownStatus              string             `protobuf:"bytes,8,opt,name=cafeDownStatus,proto3" json:"cafeDownStatus,omitempty"`
	TotalRecords                int32              `protobuf:"varint,9,opt,name=totalRecords,proto3" json:"totalRecords,omitempty"`
	TotalSize                   int32              `protobuf:"varint,10,opt,name=totalSize,proto3" json:"totalSize,omitempty"`
	Error                       string             `protobuf:"bytes,11,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcDebugthreadInfo) Reset()         { *m = RpcDebugthreadInfo{} }
func (m *RpcDebugthreadInfo) String() string { return proto.CompactTextString(m) }
func (*RpcDebugthreadInfo) ProtoMessage()    {}
func (*RpcDebugthreadInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 1}
}
func (m *RpcDebugthreadInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugthreadInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugthreadInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugthreadInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugthreadInfo.Merge(m, src)
}
func (m *RpcDebugthreadInfo) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugthreadInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugthreadInfo.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugthreadInfo proto.InternalMessageInfo

func (m *RpcDebugthreadInfo) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RpcDebugthreadInfo) GetLogsWithDownloadedHead() int32 {
	if m != nil {
		return m.LogsWithDownloadedHead
	}
	return 0
}

func (m *RpcDebugthreadInfo) GetLogsWithWholeTreeDownloaded() int32 {
	if m != nil {
		return m.LogsWithWholeTreeDownloaded
	}
	return 0
}

func (m *RpcDebugthreadInfo) GetLogs() []*RpcDebuglogInfo {
	if m != nil {
		return m.Logs
	}
	return nil
}

func (m *RpcDebugthreadInfo) GetOwnLogHasCafeReplicator() bool {
	if m != nil {
		return m.OwnLogHasCafeReplicator
	}
	return false
}

func (m *RpcDebugthreadInfo) GetCafeLastPullSecAgo() int32 {
	if m != nil {
		return m.CafeLastPullSecAgo
	}
	return 0
}

func (m *RpcDebugthreadInfo) GetCafeUpStatus() string {
	if m != nil {
		return m.CafeUpStatus
	}
	return ""
}

func (m *RpcDebugthreadInfo) GetCafeDownStatus() string {
	if m != nil {
		return m.CafeDownStatus
	}
	return ""
}

func (m *RpcDebugthreadInfo) GetTotalRecords() int32 {
	if m != nil {
		return m.TotalRecords
	}
	return 0
}

func (m *RpcDebugthreadInfo) GetTotalSize() int32 {
	if m != nil {
		return m.TotalSize
	}
	return 0
}

func (m *RpcDebugthreadInfo) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type RpcDebugSync struct {
}

func (m *RpcDebugSync) Reset()         { *m = RpcDebugSync{} }
func (m *RpcDebugSync) String() string { return proto.CompactTextString(m) }
func (*RpcDebugSync) ProtoMessage()    {}
func (*RpcDebugSync) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 2}
}
func (m *RpcDebugSync) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugSync) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugSync.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugSync) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugSync.Merge(m, src)
}
func (m *RpcDebugSync) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugSync) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugSync.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugSync proto.InternalMessageInfo

type RpcDebugSyncRequest struct {
	RecordsTraverseLimit       int32 `protobuf:"varint,1,opt,name=recordsTraverseLimit,proto3" json:"recordsTraverseLimit,omitempty"`
	SkipEmptyLogs              bool  `protobuf:"varint,2,opt,name=skipEmptyLogs,proto3" json:"skipEmptyLogs,omitempty"`
	TryToDownloadRemoteRecords bool  `protobuf:"varint,3,opt,name=tryToDownloadRemoteRecords,proto3" json:"tryToDownloadRemoteRecords,omitempty"`
}

func (m *RpcDebugSyncRequest) Reset()         { *m = RpcDebugSyncRequest{} }
func (m *RpcDebugSyncRequest) String() string { return proto.CompactTextString(m) }
func (*RpcDebugSyncRequest) ProtoMessage()    {}
func (*RpcDebugSyncRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 2, 0}
}
func (m *RpcDebugSyncRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugSyncRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugSyncRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugSyncRequest.Merge(m, src)
}
func (m *RpcDebugSyncRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugSyncRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugSyncRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugSyncRequest proto.InternalMessageInfo

func (m *RpcDebugSyncRequest) GetRecordsTraverseLimit() int32 {
	if m != nil {
		return m.RecordsTraverseLimit
	}
	return 0
}

func (m *RpcDebugSyncRequest) GetSkipEmptyLogs() bool {
	if m != nil {
		return m.SkipEmptyLogs
	}
	return false
}

func (m *RpcDebugSyncRequest) GetTryToDownloadRemoteRecords() bool {
	if m != nil {
		return m.TryToDownloadRemoteRecords
	}
	return false
}

type RpcDebugSyncResponse struct {
	Error                        *RpcDebugSyncResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Threads                      []*RpcDebugthreadInfo      `protobuf:"bytes,2,rep,name=threads,proto3" json:"threads,omitempty"`
	DeviceId                     string                     `protobuf:"bytes,3,opt,name=deviceId,proto3" json:"deviceId,omitempty"`
	TotalThreads                 int32                      `protobuf:"varint,4,opt,name=totalThreads,proto3" json:"totalThreads,omitempty"`
	ThreadsWithoutReplInOwnLog   int32                      `protobuf:"varint,5,opt,name=threadsWithoutReplInOwnLog,proto3" json:"threadsWithoutReplInOwnLog,omitempty"`
	ThreadsWithoutHeadDownloaded int32                      `protobuf:"varint,6,opt,name=threadsWithoutHeadDownloaded,proto3" json:"threadsWithoutHeadDownloaded,omitempty"`
	TotalRecords                 int32                      `protobuf:"varint,7,opt,name=totalRecords,proto3" json:"totalRecords,omitempty"`
	TotalSize                    int32                      `protobuf:"varint,8,opt,name=totalSize,proto3" json:"totalSize,omitempty"`
}

func (m *RpcDebugSyncResponse) Reset()         { *m = RpcDebugSyncResponse{} }
func (m *RpcDebugSyncResponse) String() string { return proto.CompactTextString(m) }
func (*RpcDebugSyncResponse) ProtoMessage()    {}
func (*RpcDebugSyncResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 2, 1}
}
func (m *RpcDebugSyncResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugSyncResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugSyncResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugSyncResponse.Merge(m, src)
}
func (m *RpcDebugSyncResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugSyncResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugSyncResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugSyncResponse proto.InternalMessageInfo

func (m *RpcDebugSyncResponse) GetError() *RpcDebugSyncResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcDebugSyncResponse) GetThreads() []*RpcDebugthreadInfo {
	if m != nil {
		return m.Threads
	}
	return nil
}

func (m *RpcDebugSyncResponse) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *RpcDebugSyncResponse) GetTotalThreads() int32 {
	if m != nil {
		return m.TotalThreads
	}
	return 0
}

func (m *RpcDebugSyncResponse) GetThreadsWithoutReplInOwnLog() int32 {
	if m != nil {
		return m.ThreadsWithoutReplInOwnLog
	}
	return 0
}

func (m *RpcDebugSyncResponse) GetThreadsWithoutHeadDownloaded() int32 {
	if m != nil {
		return m.ThreadsWithoutHeadDownloaded
	}
	return 0
}

func (m *RpcDebugSyncResponse) GetTotalRecords() int32 {
	if m != nil {
		return m.TotalRecords
	}
	return 0
}

func (m *RpcDebugSyncResponse) GetTotalSize() int32 {
	if m != nil {
		return m.TotalSize
	}
	return 0
}

type RpcDebugSyncResponseError struct {
	Code        RpcDebugSyncResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcDebugSyncResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcDebugSyncResponseError) Reset()         { *m = RpcDebugSyncResponseError{} }
func (m *RpcDebugSyncResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcDebugSyncResponseError) ProtoMessage()    {}
func (*RpcDebugSyncResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 2, 1, 0}
}
func (m *RpcDebugSyncResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugSyncResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugSyncResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugSyncResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugSyncResponseError.Merge(m, src)
}
func (m *RpcDebugSyncResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugSyncResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugSyncResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugSyncResponseError proto.InternalMessageInfo

func (m *RpcDebugSyncResponseError) GetCode() RpcDebugSyncResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcDebugSyncResponseError_NULL
}

func (m *RpcDebugSyncResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcDebugThread struct {
}

func (m *RpcDebugThread) Reset()         { *m = RpcDebugThread{} }
func (m *RpcDebugThread) String() string { return proto.CompactTextString(m) }
func (*RpcDebugThread) ProtoMessage()    {}
func (*RpcDebugThread) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 3}
}
func (m *RpcDebugThread) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugThread) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugThread.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugThread) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugThread.Merge(m, src)
}
func (m *RpcDebugThread) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugThread) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugThread.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugThread proto.InternalMessageInfo

type RpcDebugThreadRequest struct {
	ThreadId                   string `protobuf:"bytes,1,opt,name=threadId,proto3" json:"threadId,omitempty"`
	SkipEmptyLogs              bool   `protobuf:"varint,2,opt,name=skipEmptyLogs,proto3" json:"skipEmptyLogs,omitempty"`
	TryToDownloadRemoteRecords bool   `protobuf:"varint,3,opt,name=tryToDownloadRemoteRecords,proto3" json:"tryToDownloadRemoteRecords,omitempty"`
}

func (m *RpcDebugThreadRequest) Reset()         { *m = RpcDebugThreadRequest{} }
func (m *RpcDebugThreadRequest) String() string { return proto.CompactTextString(m) }
func (*RpcDebugThreadRequest) ProtoMessage()    {}
func (*RpcDebugThreadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 3, 0}
}
func (m *RpcDebugThreadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugThreadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugThreadRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugThreadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugThreadRequest.Merge(m, src)
}
func (m *RpcDebugThreadRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugThreadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugThreadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugThreadRequest proto.InternalMessageInfo

func (m *RpcDebugThreadRequest) GetThreadId() string {
	if m != nil {
		return m.ThreadId
	}
	return ""
}

func (m *RpcDebugThreadRequest) GetSkipEmptyLogs() bool {
	if m != nil {
		return m.SkipEmptyLogs
	}
	return false
}

func (m *RpcDebugThreadRequest) GetTryToDownloadRemoteRecords() bool {
	if m != nil {
		return m.TryToDownloadRemoteRecords
	}
	return false
}

type RpcDebugThreadResponse struct {
	Error *RpcDebugThreadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Info  *RpcDebugthreadInfo          `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
}

func (m *RpcDebugThreadResponse) Reset()         { *m = RpcDebugThreadResponse{} }
func (m *RpcDebugThreadResponse) String() string { return proto.CompactTextString(m) }
func (*RpcDebugThreadResponse) ProtoMessage()    {}
func (*RpcDebugThreadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 3, 1}
}
func (m *RpcDebugThreadResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugThreadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugThreadResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugThreadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugThreadResponse.Merge(m, src)
}
func (m *RpcDebugThreadResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugThreadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugThreadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugThreadResponse proto.InternalMessageInfo

func (m *RpcDebugThreadResponse) GetError() *RpcDebugThreadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcDebugThreadResponse) GetInfo() *RpcDebugthreadInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

type RpcDebugThreadResponseError struct {
	Code        RpcDebugThreadResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcDebugThreadResponseErrorCode" json:"code,omitempty"`
	Description string                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcDebugThreadResponseError) Reset()         { *m = RpcDebugThreadResponseError{} }
func (m *RpcDebugThreadResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcDebugThreadResponseError) ProtoMessage()    {}
func (*RpcDebugThreadResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 3, 1, 0}
}
func (m *RpcDebugThreadResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugThreadResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugThreadResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugThreadResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugThreadResponseError.Merge(m, src)
}
func (m *RpcDebugThreadResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugThreadResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugThreadResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugThreadResponseError proto.InternalMessageInfo

func (m *RpcDebugThreadResponseError) GetCode() RpcDebugThreadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcDebugThreadResponseError_NULL
}

func (m *RpcDebugThreadResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcDebugTree struct {
}

func (m *RpcDebugTree) Reset()         { *m = RpcDebugTree{} }
func (m *RpcDebugTree) String() string { return proto.CompactTextString(m) }
func (*RpcDebugTree) ProtoMessage()    {}
func (*RpcDebugTree) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 4}
}
func (m *RpcDebugTree) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugTree) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugTree.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugTree) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugTree.Merge(m, src)
}
func (m *RpcDebugTree) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugTree) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugTree.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugTree proto.InternalMessageInfo

type RpcDebugTreeRequest struct {
	BlockId      string `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Path         string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Unanonymized bool   `protobuf:"varint,3,opt,name=unanonymized,proto3" json:"unanonymized,omitempty"`
}

func (m *RpcDebugTreeRequest) Reset()         { *m = RpcDebugTreeRequest{} }
func (m *RpcDebugTreeRequest) String() string { return proto.CompactTextString(m) }
func (*RpcDebugTreeRequest) ProtoMessage()    {}
func (*RpcDebugTreeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 4, 0}
}
func (m *RpcDebugTreeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugTreeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugTreeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugTreeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugTreeRequest.Merge(m, src)
}
func (m *RpcDebugTreeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugTreeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugTreeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugTreeRequest proto.InternalMessageInfo

func (m *RpcDebugTreeRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcDebugTreeRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcDebugTreeRequest) GetUnanonymized() bool {
	if m != nil {
		return m.Unanonymized
	}
	return false
}

type RpcDebugTreeResponse struct {
	Error    *RpcDebugTreeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Filename string                     `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"`
}

func (m *RpcDebugTreeResponse) Reset()         { *m = RpcDebugTreeResponse{} }
func (m *RpcDebugTreeResponse) String() string { return proto.CompactTextString(m) }
func (*RpcDebugTreeResponse) ProtoMessage()    {}
func (*RpcDebugTreeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 4, 1}
}
func (m *RpcDebugTreeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugTreeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugTreeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugTreeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugTreeResponse.Merge(m, src)
}
func (m *RpcDebugTreeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugTreeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugTreeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugTreeResponse proto.InternalMessageInfo

func (m *RpcDebugTreeResponse) GetError() *RpcDebugTreeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcDebugTreeResponse) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

type RpcDebugTreeResponseError struct {
	Code        RpcDebugTreeResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcDebugTreeResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcDebugTreeResponseError) Reset()         { *m = RpcDebugTreeResponseError{} }
func (m *RpcDebugTreeResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcDebugTreeResponseError) ProtoMessage()    {}
func (*RpcDebugTreeResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 36, 4, 1, 0}
}
func (m *RpcDebugTreeResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugTreeResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugTreeResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugTreeResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugTreeResponseError.Merge(m, src)
}
func (m *RpcDebugTreeResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugTreeResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugTreeResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugTreeResponseError proto.InternalMessageInfo

func (m *RpcDebugTreeResponseError) GetCode() RpcDebugTreeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcDebugTreeResponseError_NULL
}

func (m *RpcDebugTreeResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcGenericErrorResponse struct {
	Error *RpcGenericErrorResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcGenericErrorResponse) Reset()         { *m = RpcGenericErrorResponse{} }
func (m *RpcGenericErrorResponse) String() string { return proto.CompactTextString(m) }
func (*RpcGenericErrorResponse) ProtoMessage()    {}
func (*RpcGenericErrorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 37}
}
func (m *RpcGenericErrorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcGenericErrorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcGenericErrorResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcGenericErrorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcGenericErrorResponse.Merge(m, src)
}
func (m *RpcGenericErrorResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcGenericErrorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcGenericErrorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcGenericErrorResponse proto.InternalMessageInfo

func (m *RpcGenericErrorResponse) GetError() *RpcGenericErrorResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcGenericErrorResponseError struct {
	Code        RpcGenericErrorResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcGenericErrorResponseErrorCode" json:"code,omitempty"`
	Description string                           `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcGenericErrorResponseError) Reset()         { *m = RpcGenericErrorResponseError{} }
func (m *RpcGenericErrorResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcGenericErrorResponseError) ProtoMessage()    {}
func (*RpcGenericErrorResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 37, 0}
}
func (m *RpcGenericErrorResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcGenericErrorResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcGenericErrorResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcGenericErrorResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcGenericErrorResponseError.Merge(m, src)
}
func (m *RpcGenericErrorResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcGenericErrorResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcGenericErrorResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcGenericErrorResponseError proto.InternalMessageInfo

func (m *RpcGenericErrorResponseError) GetCode() RpcGenericErrorResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcGenericErrorResponseError_NULL
}

func (m *RpcGenericErrorResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type Empty struct {
}

func (m *Empty) Reset()         { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()    {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{1}
}
func (m *Empty) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return m.Size()
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("anytype.RpcMetricsSetParametersResponseErrorCode", RpcMetricsSetParametersResponseErrorCode_name, RpcMetricsSetParametersResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcExternalDropFilesResponseErrorCode", RpcExternalDropFilesResponseErrorCode_name, RpcExternalDropFilesResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcExternalDropContentResponseErrorCode", RpcExternalDropContentResponseErrorCode_name, RpcExternalDropContentResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListConvertChildrenToPagesResponseErrorCode", RpcBlockListConvertChildrenToPagesResponseErrorCode_name, RpcBlockListConvertChildrenToPagesResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListMoveResponseErrorCode", RpcBlockListMoveResponseErrorCode_name, RpcBlockListMoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListMoveToNewPageResponseErrorCode", RpcBlockListMoveToNewPageResponseErrorCode_name, RpcBlockListMoveToNewPageResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListDuplicateResponseErrorCode", RpcBlockListDuplicateResponseErrorCode_name, RpcBlockListDuplicateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetTextStyleResponseErrorCode", RpcBlockListSetTextStyleResponseErrorCode_name, RpcBlockListSetTextStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetTextColorResponseErrorCode", RpcBlockListSetTextColorResponseErrorCode_name, RpcBlockListSetTextColorResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetTextMarkResponseErrorCode", RpcBlockListSetTextMarkResponseErrorCode_name, RpcBlockListSetTextMarkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetBackgroundColorResponseErrorCode", RpcBlockListSetBackgroundColorResponseErrorCode_name, RpcBlockListSetBackgroundColorResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetAlignResponseErrorCode", RpcBlockListSetAlignResponseErrorCode_name, RpcBlockListSetAlignResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetFieldsResponseErrorCode", RpcBlockListSetFieldsResponseErrorCode_name, RpcBlockListSetFieldsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetDivStyleResponseErrorCode", RpcBlockListSetDivStyleResponseErrorCode_name, RpcBlockListSetDivStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetFileStyleResponseErrorCode", RpcBlockListSetFileStyleResponseErrorCode_name, RpcBlockListSetFileStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListTurnIntoResponseErrorCode", RpcBlockListTurnIntoResponseErrorCode_name, RpcBlockListTurnIntoResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockReplaceResponseErrorCode", RpcBlockReplaceResponseErrorCode_name, RpcBlockReplaceResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockUpdateContentResponseErrorCode", RpcBlockUpdateContentResponseErrorCode_name, RpcBlockUpdateContentResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSplitRequestMode", RpcBlockSplitRequestMode_name, RpcBlockSplitRequestMode_value)
	proto.RegisterEnum("anytype.RpcBlockSplitResponseErrorCode", RpcBlockSplitResponseErrorCode_name, RpcBlockSplitResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockMergeResponseErrorCode", RpcBlockMergeResponseErrorCode_name, RpcBlockMergeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCopyResponseErrorCode", RpcBlockCopyResponseErrorCode_name, RpcBlockCopyResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockPasteResponseErrorCode", RpcBlockPasteResponseErrorCode_name, RpcBlockPasteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCutResponseErrorCode", RpcBlockCutResponseErrorCode_name, RpcBlockCutResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockImportMarkdownResponseErrorCode", RpcBlockImportMarkdownResponseErrorCode_name, RpcBlockImportMarkdownResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockExportResponseErrorCode", RpcBlockExportResponseErrorCode_name, RpcBlockExportResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockUploadResponseErrorCode", RpcBlockUploadResponseErrorCode_name, RpcBlockUploadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDownloadResponseErrorCode", RpcBlockDownloadResponseErrorCode_name, RpcBlockDownloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetFieldsResponseErrorCode", RpcBlockSetFieldsResponseErrorCode_name, RpcBlockSetFieldsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetDetailsResponseErrorCode", RpcBlockSetDetailsResponseErrorCode_name, RpcBlockSetDetailsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetRestrictionsResponseErrorCode", RpcBlockSetRestrictionsResponseErrorCode_name, RpcBlockSetRestrictionsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetPageIsArchivedResponseErrorCode", RpcBlockSetPageIsArchivedResponseErrorCode_name, RpcBlockSetPageIsArchivedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetLatexTextResponseErrorCode", RpcBlockSetLatexTextResponseErrorCode_name, RpcBlockSetLatexTextResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetTextTextResponseErrorCode", RpcBlockSetTextTextResponseErrorCode_name, RpcBlockSetTextTextResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetTextColorResponseErrorCode", RpcBlockSetTextColorResponseErrorCode_name, RpcBlockSetTextColorResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetTextStyleResponseErrorCode", RpcBlockSetTextStyleResponseErrorCode_name, RpcBlockSetTextStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetTextCheckedResponseErrorCode", RpcBlockSetTextCheckedResponseErrorCode_name, RpcBlockSetTextCheckedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetTextIconResponseErrorCode", RpcBlockSetTextIconResponseErrorCode_name, RpcBlockSetTextIconResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetFileNameResponseErrorCode", RpcBlockSetFileNameResponseErrorCode_name, RpcBlockSetFileNameResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetImageNameResponseErrorCode", RpcBlockSetImageNameResponseErrorCode_name, RpcBlockSetImageNameResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetImageWidthResponseErrorCode", RpcBlockSetImageWidthResponseErrorCode_name, RpcBlockSetImageWidthResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetVideoNameResponseErrorCode", RpcBlockSetVideoNameResponseErrorCode_name, RpcBlockSetVideoNameResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetVideoWidthResponseErrorCode", RpcBlockSetVideoWidthResponseErrorCode_name, RpcBlockSetVideoWidthResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetLinkTargetBlockIdResponseErrorCode", RpcBlockSetLinkTargetBlockIdResponseErrorCode_name, RpcBlockSetLinkTargetBlockIdResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockRelationSetKeyResponseErrorCode", RpcBlockRelationSetKeyResponseErrorCode_name, RpcBlockRelationSetKeyResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockRelationAddResponseErrorCode", RpcBlockRelationAddResponseErrorCode_name, RpcBlockRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockObjectTypeSetResponseErrorCode", RpcBlockObjectTypeSetResponseErrorCode_name, RpcBlockObjectTypeSetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockBookmarkFetchResponseErrorCode", RpcBlockBookmarkFetchResponseErrorCode_name, RpcBlockBookmarkFetchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockBookmarkCreateAndFetchResponseErrorCode", RpcBlockBookmarkCreateAndFetchResponseErrorCode_name, RpcBlockBookmarkCreateAndFetchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockFileCreateAndUploadResponseErrorCode", RpcBlockFileCreateAndUploadResponseErrorCode_name, RpcBlockFileCreateAndUploadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewViewCreateResponseErrorCode", RpcBlockDataviewViewCreateResponseErrorCode_name, RpcBlockDataviewViewCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewViewUpdateResponseErrorCode", RpcBlockDataviewViewUpdateResponseErrorCode_name, RpcBlockDataviewViewUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewViewDeleteResponseErrorCode", RpcBlockDataviewViewDeleteResponseErrorCode_name, RpcBlockDataviewViewDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewViewSetPositionResponseErrorCode", RpcBlockDataviewViewSetPositionResponseErrorCode_name, RpcBlockDataviewViewSetPositionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewViewSetActiveResponseErrorCode", RpcBlockDataviewViewSetActiveResponseErrorCode_name, RpcBlockDataviewViewSetActiveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRecordUpdateResponseErrorCode", RpcBlockDataviewRecordUpdateResponseErrorCode_name, RpcBlockDataviewRecordUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRecordDeleteResponseErrorCode", RpcBlockDataviewRecordDeleteResponseErrorCode_name, RpcBlockDataviewRecordDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRecordCreateResponseErrorCode", RpcBlockDataviewRecordCreateResponseErrorCode_name, RpcBlockDataviewRecordCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRelationAddResponseErrorCode", RpcBlockDataviewRelationAddResponseErrorCode_name, RpcBlockDataviewRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRelationUpdateResponseErrorCode", RpcBlockDataviewRelationUpdateResponseErrorCode_name, RpcBlockDataviewRelationUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRelationDeleteResponseErrorCode", RpcBlockDataviewRelationDeleteResponseErrorCode_name, RpcBlockDataviewRelationDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRecordRelationOptionAddResponseErrorCode", RpcBlockDataviewRecordRelationOptionAddResponseErrorCode_name, RpcBlockDataviewRecordRelationOptionAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode", RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode_name, RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode", RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode_name, RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRelationListAvailableResponseErrorCode", RpcBlockDataviewRelationListAvailableResponseErrorCode_name, RpcBlockDataviewRelationListAvailableResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewSetSourceResponseErrorCode", RpcBlockDataviewSetSourceResponseErrorCode_name, RpcBlockDataviewSetSourceResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockGetMarksResponseErrorCode", RpcBlockGetMarksResponseErrorCode_name, RpcBlockGetMarksResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockUndoResponseErrorCode", RpcBlockUndoResponseErrorCode_name, RpcBlockUndoResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockRedoResponseErrorCode", RpcBlockRedoResponseErrorCode_name, RpcBlockRedoResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockOpenResponseErrorCode", RpcBlockOpenResponseErrorCode_name, RpcBlockOpenResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockShowResponseErrorCode", RpcBlockShowResponseErrorCode_name, RpcBlockShowResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockGetPublicWebURLResponseErrorCode", RpcBlockGetPublicWebURLResponseErrorCode_name, RpcBlockGetPublicWebURLResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockOpenBreadcrumbsResponseErrorCode", RpcBlockOpenBreadcrumbsResponseErrorCode_name, RpcBlockOpenBreadcrumbsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetBreadcrumbsResponseErrorCode", RpcBlockSetBreadcrumbsResponseErrorCode_name, RpcBlockSetBreadcrumbsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCreateResponseErrorCode", RpcBlockCreateResponseErrorCode_name, RpcBlockCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCreatePageResponseErrorCode", RpcBlockCreatePageResponseErrorCode_name, RpcBlockCreatePageResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCreateSetResponseErrorCode", RpcBlockCreateSetResponseErrorCode_name, RpcBlockCreateSetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockUnlinkResponseErrorCode", RpcBlockUnlinkResponseErrorCode_name, RpcBlockUnlinkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCloseResponseErrorCode", RpcBlockCloseResponseErrorCode_name, RpcBlockCloseResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceGetCurrentResponseErrorCode", RpcWorkspaceGetCurrentResponseErrorCode_name, RpcWorkspaceGetCurrentResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceGetAllResponseErrorCode", RpcWorkspaceGetAllResponseErrorCode_name, RpcWorkspaceGetAllResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceCreateResponseErrorCode", RpcWorkspaceCreateResponseErrorCode_name, RpcWorkspaceCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceSetIsHighlightedResponseErrorCode", RpcWorkspaceSetIsHighlightedResponseErrorCode_name, RpcWorkspaceSetIsHighlightedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceSelectResponseErrorCode", RpcWorkspaceSelectResponseErrorCode_name, RpcWorkspaceSelectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWalletCreateResponseErrorCode", RpcWalletCreateResponseErrorCode_name, RpcWalletCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWalletRecoverResponseErrorCode", RpcWalletRecoverResponseErrorCode_name, RpcWalletRecoverResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWalletConvertResponseErrorCode", RpcWalletConvertResponseErrorCode_name, RpcWalletConvertResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountCreateResponseErrorCode", RpcAccountCreateResponseErrorCode_name, RpcAccountCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountRecoverResponseErrorCode", RpcAccountRecoverResponseErrorCode_name, RpcAccountRecoverResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountSelectResponseErrorCode", RpcAccountSelectResponseErrorCode_name, RpcAccountSelectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountStopResponseErrorCode", RpcAccountStopResponseErrorCode_name, RpcAccountStopResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcLogSendRequestLevel", RpcLogSendRequestLevel_name, RpcLogSendRequestLevel_value)
	proto.RegisterEnum("anytype.RpcLogSendResponseErrorCode", RpcLogSendResponseErrorCode_name, RpcLogSendResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcVersionGetResponseErrorCode", RpcVersionGetResponseErrorCode_name, RpcVersionGetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileOffloadResponseErrorCode", RpcFileOffloadResponseErrorCode_name, RpcFileOffloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileListOffloadResponseErrorCode", RpcFileListOffloadResponseErrorCode_name, RpcFileListOffloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcShutdownResponseErrorCode", RpcShutdownResponseErrorCode_name, RpcShutdownResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcConfigGetResponseErrorCode", RpcConfigGetResponseErrorCode_name, RpcConfigGetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcPingResponseErrorCode", RpcPingResponseErrorCode_name, RpcPingResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcProcessCancelResponseErrorCode", RpcProcessCancelResponseErrorCode_name, RpcProcessCancelResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcLinkPreviewResponseErrorCode", RpcLinkPreviewResponseErrorCode_name, RpcLinkPreviewResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcUploadFileResponseErrorCode", RpcUploadFileResponseErrorCode_name, RpcUploadFileResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcDownloadFileResponseErrorCode", RpcDownloadFileResponseErrorCode_name, RpcDownloadFileResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcNavigationContext", RpcNavigationContext_name, RpcNavigationContext_value)
	proto.RegisterEnum("anytype.RpcNavigationListObjectsResponseErrorCode", RpcNavigationListObjectsResponseErrorCode_name, RpcNavigationListObjectsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcNavigationGetObjectInfoWithLinksResponseErrorCode", RpcNavigationGetObjectInfoWithLinksResponseErrorCode_name, RpcNavigationGetObjectInfoWithLinksResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcHistoryVersionsResponseErrorCode", RpcHistoryVersionsResponseErrorCode_name, RpcHistoryVersionsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcHistoryShowResponseErrorCode", RpcHistoryShowResponseErrorCode_name, RpcHistoryShowResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcHistorySetVersionResponseErrorCode", RpcHistorySetVersionResponseErrorCode_name, RpcHistorySetVersionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcPageCreateResponseErrorCode", RpcPageCreateResponseErrorCode_name, RpcPageCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcSetCreateResponseErrorCode", RpcSetCreateResponseErrorCode_name, RpcSetCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeListResponseErrorCode", RpcObjectTypeListResponseErrorCode_name, RpcObjectTypeListResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeCreateResponseErrorCode", RpcObjectTypeCreateResponseErrorCode_name, RpcObjectTypeCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationAddResponseErrorCode", RpcObjectTypeRelationAddResponseErrorCode_name, RpcObjectTypeRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationRemoveResponseErrorCode", RpcObjectTypeRelationRemoveResponseErrorCode_name, RpcObjectTypeRelationRemoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationUpdateResponseErrorCode", RpcObjectTypeRelationUpdateResponseErrorCode_name, RpcObjectTypeRelationUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationListResponseErrorCode", RpcObjectTypeRelationListResponseErrorCode_name, RpcObjectTypeRelationListResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectShareByLinkResponseErrorCode", RpcObjectShareByLinkResponseErrorCode_name, RpcObjectShareByLinkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectAddWithObjectIdResponseErrorCode", RpcObjectAddWithObjectIdResponseErrorCode_name, RpcObjectAddWithObjectIdResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationAddResponseErrorCode", RpcObjectRelationAddResponseErrorCode_name, RpcObjectRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationUpdateResponseErrorCode", RpcObjectRelationUpdateResponseErrorCode_name, RpcObjectRelationUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationDeleteResponseErrorCode", RpcObjectRelationDeleteResponseErrorCode_name, RpcObjectRelationDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationOptionAddResponseErrorCode", RpcObjectRelationOptionAddResponseErrorCode_name, RpcObjectRelationOptionAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationOptionUpdateResponseErrorCode", RpcObjectRelationOptionUpdateResponseErrorCode_name, RpcObjectRelationOptionUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationOptionDeleteResponseErrorCode", RpcObjectRelationOptionDeleteResponseErrorCode_name, RpcObjectRelationOptionDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationListAvailableResponseErrorCode", RpcObjectRelationListAvailableResponseErrorCode_name, RpcObjectRelationListAvailableResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSearchResponseErrorCode", RpcObjectSearchResponseErrorCode_name, RpcObjectSearchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectGraphEdgeType", RpcObjectGraphEdgeType_name, RpcObjectGraphEdgeType_value)
	proto.RegisterEnum("anytype.RpcObjectGraphResponseErrorCode", RpcObjectGraphResponseErrorCode_name, RpcObjectGraphResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSearchSubscribeResponseErrorCode", RpcObjectSearchSubscribeResponseErrorCode_name, RpcObjectSearchSubscribeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectIdsSubscribeResponseErrorCode", RpcObjectIdsSubscribeResponseErrorCode_name, RpcObjectIdsSubscribeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSearchUnsubscribeResponseErrorCode", RpcObjectSearchUnsubscribeResponseErrorCode_name, RpcObjectSearchUnsubscribeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSetLayoutResponseErrorCode", RpcObjectSetLayoutResponseErrorCode_name, RpcObjectSetLayoutResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSetIsFavoriteResponseErrorCode", RpcObjectSetIsFavoriteResponseErrorCode_name, RpcObjectSetIsFavoriteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSetIsArchivedResponseErrorCode", RpcObjectSetIsArchivedResponseErrorCode_name, RpcObjectSetIsArchivedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectFeaturedRelationAddResponseErrorCode", RpcObjectFeaturedRelationAddResponseErrorCode_name, RpcObjectFeaturedRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectFeaturedRelationRemoveResponseErrorCode", RpcObjectFeaturedRelationRemoveResponseErrorCode_name, RpcObjectFeaturedRelationRemoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectToSetResponseErrorCode", RpcObjectToSetResponseErrorCode_name, RpcObjectToSetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectListDeleteResponseErrorCode", RpcObjectListDeleteResponseErrorCode_name, RpcObjectListDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectListSetIsArchivedResponseErrorCode", RpcObjectListSetIsArchivedResponseErrorCode_name, RpcObjectListSetIsArchivedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectListSetIsFavoriteResponseErrorCode", RpcObjectListSetIsFavoriteResponseErrorCode_name, RpcObjectListSetIsFavoriteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcExportFormat", RpcExportFormat_name, RpcExportFormat_value)
	proto.RegisterEnum("anytype.RpcExportResponseErrorCode", RpcExportResponseErrorCode_name, RpcExportResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcExportWorkspaceResponseErrorCode", RpcExportWorkspaceResponseErrorCode_name, RpcExportWorkspaceResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcExportTemplatesResponseErrorCode", RpcExportTemplatesResponseErrorCode_name, RpcExportTemplatesResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcExportLocalstoreResponseErrorCode", RpcExportLocalstoreResponseErrorCode_name, RpcExportLocalstoreResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcMakeTemplateResponseErrorCode", RpcMakeTemplateResponseErrorCode_name, RpcMakeTemplateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcMakeTemplateByObjectTypeResponseErrorCode", RpcMakeTemplateByObjectTypeResponseErrorCode_name, RpcMakeTemplateByObjectTypeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcCloneTemplateResponseErrorCode", RpcCloneTemplateResponseErrorCode_name, RpcCloneTemplateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectDuplicateResponseErrorCode", RpcObjectDuplicateResponseErrorCode_name, RpcObjectDuplicateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcUnsplashSearchResponseErrorCode", RpcUnsplashSearchResponseErrorCode_name, RpcUnsplashSearchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcUnsplashDownloadResponseErrorCode", RpcUnsplashDownloadResponseErrorCode_name, RpcUnsplashDownloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcApplyTemplateResponseErrorCode", RpcApplyTemplateResponseErrorCode_name, RpcApplyTemplateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcDebugSyncResponseErrorCode", RpcDebugSyncResponseErrorCode_name, RpcDebugSyncResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcDebugThreadResponseErrorCode", RpcDebugThreadResponseErrorCode_name, RpcDebugThreadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcDebugTreeResponseErrorCode", RpcDebugTreeResponseErrorCode_name, RpcDebugTreeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcGenericErrorResponseErrorCode", RpcGenericErrorResponseErrorCode_name, RpcGenericErrorResponseErrorCode_value)
	proto.RegisterType((*Rpc)(nil), "anytype.Rpc")
	proto.RegisterType((*RpcMetrics)(nil), "anytype.Rpc.Metrics")
	proto.RegisterType((*RpcMetricsSetParameters)(nil), "anytype.Rpc.Metrics.SetParameters")
	proto.RegisterType((*RpcMetricsSetParametersRequest)(nil), "anytype.Rpc.Metrics.SetParameters.Request")
	proto.RegisterType((*RpcMetricsSetParametersResponse)(nil), "anytype.Rpc.Metrics.SetParameters.Response")
	proto.RegisterType((*RpcMetricsSetParametersResponseError)(nil), "anytype.Rpc.Metrics.SetParameters.Response.Error")
	proto.RegisterType((*RpcExternalDrop)(nil), "anytype.Rpc.ExternalDrop")
	proto.RegisterType((*RpcExternalDropFiles)(nil), "anytype.Rpc.ExternalDrop.Files")
	proto.RegisterType((*RpcExternalDropFilesRequest)(nil), "anytype.Rpc.ExternalDrop.Files.Request")
	proto.RegisterType((*RpcExternalDropFilesResponse)(nil), "anytype.Rpc.ExternalDrop.Files.Response")
	proto.RegisterType((*RpcExternalDropFilesResponseError)(nil), "anytype.Rpc.ExternalDrop.Files.Response.Error")
	proto.RegisterType((*RpcExternalDropContent)(nil), "anytype.Rpc.ExternalDrop.Content")
	proto.RegisterType((*RpcExternalDropContentRequest)(nil), "anytype.Rpc.ExternalDrop.Content.Request")
	proto.RegisterType((*RpcExternalDropContentResponse)(nil), "anytype.Rpc.ExternalDrop.Content.Response")
	proto.RegisterType((*RpcExternalDropContentResponseError)(nil), "anytype.Rpc.ExternalDrop.Content.Response.Error")
	proto.RegisterType((*RpcBlockList)(nil), "anytype.Rpc.BlockList")
	proto.RegisterType((*RpcBlockListConvertChildrenToPages)(nil), "anytype.Rpc.BlockList.ConvertChildrenToPages")
	proto.RegisterType((*RpcBlockListConvertChildrenToPagesRequest)(nil), "anytype.Rpc.BlockList.ConvertChildrenToPages.Request")
	proto.RegisterType((*RpcBlockListConvertChildrenToPagesResponse)(nil), "anytype.Rpc.BlockList.ConvertChildrenToPages.Response")
	proto.RegisterType((*RpcBlockListConvertChildrenToPagesResponseError)(nil), "anytype.Rpc.BlockList.ConvertChildrenToPages.Response.Error")
	proto.RegisterType((*RpcBlockListMove)(nil), "anytype.Rpc.BlockList.Move")
	proto.RegisterType((*RpcBlockListMoveRequest)(nil), "anytype.Rpc.BlockList.Move.Request")
	proto.RegisterType((*RpcBlockListMoveResponse)(nil), "anytype.Rpc.BlockList.Move.Response")
	proto.RegisterType((*RpcBlockListMoveResponseError)(nil), "anytype.Rpc.BlockList.Move.Response.Error")
	proto.RegisterType((*RpcBlockListMoveToNewPage)(nil), "anytype.Rpc.BlockList.MoveToNewPage")
	proto.RegisterType((*RpcBlockListMoveToNewPageRequest)(nil), "anytype.Rpc.BlockList.MoveToNewPage.Request")
	proto.RegisterType((*RpcBlockListMoveToNewPageResponse)(nil), "anytype.Rpc.BlockList.MoveToNewPage.Response")
	proto.RegisterType((*RpcBlockListMoveToNewPageResponseError)(nil), "anytype.Rpc.BlockList.MoveToNewPage.Response.Error")
	proto.RegisterType((*RpcBlockListDuplicate)(nil), "anytype.Rpc.BlockList.Duplicate")
	proto.RegisterType((*RpcBlockListDuplicateRequest)(nil), "anytype.Rpc.BlockList.Duplicate.Request")
	proto.RegisterType((*RpcBlockListDuplicateResponse)(nil), "anytype.Rpc.BlockList.Duplicate.Response")
	proto.RegisterType((*RpcBlockListDuplicateResponseError)(nil), "anytype.Rpc.BlockList.Duplicate.Response.Error")
	proto.RegisterType((*RpcBlockListSet)(nil), "anytype.Rpc.BlockList.Set")
	proto.RegisterType((*RpcBlockListSetText)(nil), "anytype.Rpc.BlockList.Set.Text")
	proto.RegisterType((*RpcBlockListSetTextStyle)(nil), "anytype.Rpc.BlockList.Set.Text.Style")
	proto.RegisterType((*RpcBlockListSetTextStyleRequest)(nil), "anytype.Rpc.BlockList.Set.Text.Style.Request")
	proto.RegisterType((*RpcBlockListSetTextStyleResponse)(nil), "anytype.Rpc.BlockList.Set.Text.Style.Response")
	proto.RegisterType((*RpcBlockListSetTextStyleResponseError)(nil), "anytype.Rpc.BlockList.Set.Text.Style.Response.Error")
	proto.RegisterType((*RpcBlockListSetTextColor)(nil), "anytype.Rpc.BlockList.Set.Text.Color")
	proto.RegisterType((*RpcBlockListSetTextColorRequest)(nil), "anytype.Rpc.BlockList.Set.Text.Color.Request")
	proto.RegisterType((*RpcBlockListSetTextColorResponse)(nil), "anytype.Rpc.BlockList.Set.Text.Color.Response")
	proto.RegisterType((*RpcBlockListSetTextColorResponseError)(nil), "anytype.Rpc.BlockList.Set.Text.Color.Response.Error")
	proto.RegisterType((*RpcBlockListSetTextMark)(nil), "anytype.Rpc.BlockList.Set.Text.Mark")
	proto.RegisterType((*RpcBlockListSetTextMarkRequest)(nil), "anytype.Rpc.BlockList.Set.Text.Mark.Request")
	proto.RegisterType((*RpcBlockListSetTextMarkResponse)(nil), "anytype.Rpc.BlockList.Set.Text.Mark.Response")
	proto.RegisterType((*RpcBlockListSetTextMarkResponseError)(nil), "anytype.Rpc.BlockList.Set.Text.Mark.Response.Error")
	proto.RegisterType((*RpcBlockListSetBackgroundColor)(nil), "anytype.Rpc.BlockList.Set.BackgroundColor")
	proto.RegisterType((*RpcBlockListSetBackgroundColorRequest)(nil), "anytype.Rpc.BlockList.Set.BackgroundColor.Request")
	proto.RegisterType((*RpcBlockListSetBackgroundColorResponse)(nil), "anytype.Rpc.BlockList.Set.BackgroundColor.Response")
	proto.RegisterType((*RpcBlockListSetBackgroundColorResponseError)(nil), "anytype.Rpc.BlockList.Set.BackgroundColor.Response.Error")
	proto.RegisterType((*RpcBlockListSetAlign)(nil), "anytype.Rpc.BlockList.Set.Align")
	proto.RegisterType((*RpcBlockListSetAlignRequest)(nil), "anytype.Rpc.BlockList.Set.Align.Request")
	proto.RegisterType((*RpcBlockListSetAlignResponse)(nil), "anytype.Rpc.BlockList.Set.Align.Response")
	proto.RegisterType((*RpcBlockListSetAlignResponseError)(nil), "anytype.Rpc.BlockList.Set.Align.Response.Error")
	proto.RegisterType((*RpcBlockListSetFields)(nil), "anytype.Rpc.BlockList.Set.Fields")
	proto.RegisterType((*RpcBlockListSetFieldsRequest)(nil), "anytype.Rpc.BlockList.Set.Fields.Request")
	proto.RegisterType((*RpcBlockListSetFieldsRequestBlockField)(nil), "anytype.Rpc.BlockList.Set.Fields.Request.BlockField")
	proto.RegisterType((*RpcBlockListSetFieldsResponse)(nil), "anytype.Rpc.BlockList.Set.Fields.Response")
	proto.RegisterType((*RpcBlockListSetFieldsResponseError)(nil), "anytype.Rpc.BlockList.Set.Fields.Response.Error")
	proto.RegisterType((*RpcBlockListSetDiv)(nil), "anytype.Rpc.BlockList.Set.Div")
	proto.RegisterType((*RpcBlockListSetDivStyle)(nil), "anytype.Rpc.BlockList.Set.Div.Style")
	proto.RegisterType((*RpcBlockListSetDivStyleRequest)(nil), "anytype.Rpc.BlockList.Set.Div.Style.Request")
	proto.RegisterType((*RpcBlockListSetDivStyleResponse)(nil), "anytype.Rpc.BlockList.Set.Div.Style.Response")
	proto.RegisterType((*RpcBlockListSetDivStyleResponseError)(nil), "anytype.Rpc.BlockList.Set.Div.Style.Response.Error")
	proto.RegisterType((*RpcBlockListSetFile)(nil), "anytype.Rpc.BlockList.Set.File")
	proto.RegisterType((*RpcBlockListSetFileStyle)(nil), "anytype.Rpc.BlockList.Set.File.Style")
	proto.RegisterType((*RpcBlockListSetFileStyleRequest)(nil), "anytype.Rpc.BlockList.Set.File.Style.Request")
	proto.RegisterType((*RpcBlockListSetFileStyleResponse)(nil), "anytype.Rpc.BlockList.Set.File.Style.Response")
	proto.RegisterType((*RpcBlockListSetFileStyleResponseError)(nil), "anytype.Rpc.BlockList.Set.File.Style.Response.Error")
	proto.RegisterType((*RpcBlockListTurnInto)(nil), "anytype.Rpc.BlockList.TurnInto")
	proto.RegisterType((*RpcBlockListTurnIntoRequest)(nil), "anytype.Rpc.BlockList.TurnInto.Request")
	proto.RegisterType((*RpcBlockListTurnIntoResponse)(nil), "anytype.Rpc.BlockList.TurnInto.Response")
	proto.RegisterType((*RpcBlockListTurnIntoResponseError)(nil), "anytype.Rpc.BlockList.TurnInto.Response.Error")
	proto.RegisterType((*RpcBlock)(nil), "anytype.Rpc.Block")
	proto.RegisterType((*RpcBlockReplace)(nil), "anytype.Rpc.Block.Replace")
	proto.RegisterType((*RpcBlockReplaceRequest)(nil), "anytype.Rpc.Block.Replace.Request")
	proto.RegisterType((*RpcBlockReplaceResponse)(nil), "anytype.Rpc.Block.Replace.Response")
	proto.RegisterType((*RpcBlockReplaceResponseError)(nil), "anytype.Rpc.Block.Replace.Response.Error")
	proto.RegisterType((*RpcBlockUpdateContent)(nil), "anytype.Rpc.Block.UpdateContent")
	proto.RegisterType((*RpcBlockUpdateContentRequest)(nil), "anytype.Rpc.Block.UpdateContent.Request")
	proto.RegisterType((*RpcBlockUpdateContentResponse)(nil), "anytype.Rpc.Block.UpdateContent.Response")
	proto.RegisterType((*RpcBlockUpdateContentResponseError)(nil), "anytype.Rpc.Block.UpdateContent.Response.Error")
	proto.RegisterType((*RpcBlockSplit)(nil), "anytype.Rpc.Block.Split")
	proto.RegisterType((*RpcBlockSplitRequest)(nil), "anytype.Rpc.Block.Split.Request")
	proto.RegisterType((*RpcBlockSplitResponse)(nil), "anytype.Rpc.Block.Split.Response")
	proto.RegisterType((*RpcBlockSplitResponseError)(nil), "anytype.Rpc.Block.Split.Response.Error")
	proto.RegisterType((*RpcBlockMerge)(nil), "anytype.Rpc.Block.Merge")
	proto.RegisterType((*RpcBlockMergeRequest)(nil), "anytype.Rpc.Block.Merge.Request")
	proto.RegisterType((*RpcBlockMergeResponse)(nil), "anytype.Rpc.Block.Merge.Response")
	proto.RegisterType((*RpcBlockMergeResponseError)(nil), "anytype.Rpc.Block.Merge.Response.Error")
	proto.RegisterType((*RpcBlockCopy)(nil), "anytype.Rpc.Block.Copy")
	proto.RegisterType((*RpcBlockCopyRequest)(nil), "anytype.Rpc.Block.Copy.Request")
	proto.RegisterType((*RpcBlockCopyResponse)(nil), "anytype.Rpc.Block.Copy.Response")
	proto.RegisterType((*RpcBlockCopyResponseError)(nil), "anytype.Rpc.Block.Copy.Response.Error")
	proto.RegisterType((*RpcBlockPaste)(nil), "anytype.Rpc.Block.Paste")
	proto.RegisterType((*RpcBlockPasteRequest)(nil), "anytype.Rpc.Block.Paste.Request")
	proto.RegisterType((*RpcBlockPasteRequestFile)(nil), "anytype.Rpc.Block.Paste.Request.File")
	proto.RegisterType((*RpcBlockPasteResponse)(nil), "anytype.Rpc.Block.Paste.Response")
	proto.RegisterType((*RpcBlockPasteResponseError)(nil), "anytype.Rpc.Block.Paste.Response.Error")
	proto.RegisterType((*RpcBlockCut)(nil), "anytype.Rpc.Block.Cut")
	proto.RegisterType((*RpcBlockCutRequest)(nil), "anytype.Rpc.Block.Cut.Request")
	proto.RegisterType((*RpcBlockCutResponse)(nil), "anytype.Rpc.Block.Cut.Response")
	proto.RegisterType((*RpcBlockCutResponseError)(nil), "anytype.Rpc.Block.Cut.Response.Error")
	proto.RegisterType((*RpcBlockImportMarkdown)(nil), "anytype.Rpc.Block.ImportMarkdown")
	proto.RegisterType((*RpcBlockImportMarkdownRequest)(nil), "anytype.Rpc.Block.ImportMarkdown.Request")
	proto.RegisterType((*RpcBlockImportMarkdownResponse)(nil), "anytype.Rpc.Block.ImportMarkdown.Response")
	proto.RegisterType((*RpcBlockImportMarkdownResponseError)(nil), "anytype.Rpc.Block.ImportMarkdown.Response.Error")
	proto.RegisterType((*RpcBlockExport)(nil), "anytype.Rpc.Block.Export")
	proto.RegisterType((*RpcBlockExportRequest)(nil), "anytype.Rpc.Block.Export.Request")
	proto.RegisterType((*RpcBlockExportResponse)(nil), "anytype.Rpc.Block.Export.Response")
	proto.RegisterType((*RpcBlockExportResponseError)(nil), "anytype.Rpc.Block.Export.Response.Error")
	proto.RegisterType((*RpcBlockUpload)(nil), "anytype.Rpc.Block.Upload")
	proto.RegisterType((*RpcBlockUploadRequest)(nil), "anytype.Rpc.Block.Upload.Request")
	proto.RegisterType((*RpcBlockUploadResponse)(nil), "anytype.Rpc.Block.Upload.Response")
	proto.RegisterType((*RpcBlockUploadResponseError)(nil), "anytype.Rpc.Block.Upload.Response.Error")
	proto.RegisterType((*RpcBlockDownload)(nil), "anytype.Rpc.Block.Download")
	proto.RegisterType((*RpcBlockDownloadRequest)(nil), "anytype.Rpc.Block.Download.Request")
	proto.RegisterType((*RpcBlockDownloadResponse)(nil), "anytype.Rpc.Block.Download.Response")
	proto.RegisterType((*RpcBlockDownloadResponseError)(nil), "anytype.Rpc.Block.Download.Response.Error")
	proto.RegisterType((*RpcBlockSet)(nil), "anytype.Rpc.Block.Set")
	proto.RegisterType((*RpcBlockSetFields)(nil), "anytype.Rpc.Block.Set.Fields")
	proto.RegisterType((*RpcBlockSetFieldsRequest)(nil), "anytype.Rpc.Block.Set.Fields.Request")
	proto.RegisterType((*RpcBlockSetFieldsResponse)(nil), "anytype.Rpc.Block.Set.Fields.Response")
	proto.RegisterType((*RpcBlockSetFieldsResponseError)(nil), "anytype.Rpc.Block.Set.Fields.Response.Error")
	proto.RegisterType((*RpcBlockSetDetails)(nil), "anytype.Rpc.Block.Set.Details")
	proto.RegisterType((*RpcBlockSetDetailsDetail)(nil), "anytype.Rpc.Block.Set.Details.Detail")
	proto.RegisterType((*RpcBlockSetDetailsRequest)(nil), "anytype.Rpc.Block.Set.Details.Request")
	proto.RegisterType((*RpcBlockSetDetailsResponse)(nil), "anytype.Rpc.Block.Set.Details.Response")
	proto.RegisterType((*RpcBlockSetDetailsResponseError)(nil), "anytype.Rpc.Block.Set.Details.Response.Error")
	proto.RegisterType((*RpcBlockSetRestrictions)(nil), "anytype.Rpc.Block.Set.Restrictions")
	proto.RegisterType((*RpcBlockSetRestrictionsRequest)(nil), "anytype.Rpc.Block.Set.Restrictions.Request")
	proto.RegisterType((*RpcBlockSetRestrictionsResponse)(nil), "anytype.Rpc.Block.Set.Restrictions.Response")
	proto.RegisterType((*RpcBlockSetRestrictionsResponseError)(nil), "anytype.Rpc.Block.Set.Restrictions.Response.Error")
	proto.RegisterType((*RpcBlockSetPage)(nil), "anytype.Rpc.Block.Set.Page")
	proto.RegisterType((*RpcBlockSetPageIsArchived)(nil), "anytype.Rpc.Block.Set.Page.IsArchived")
	proto.RegisterType((*RpcBlockSetPageIsArchivedRequest)(nil), "anytype.Rpc.Block.Set.Page.IsArchived.Request")
	proto.RegisterType((*RpcBlockSetPageIsArchivedResponse)(nil), "anytype.Rpc.Block.Set.Page.IsArchived.Response")
	proto.RegisterType((*RpcBlockSetPageIsArchivedResponseError)(nil), "anytype.Rpc.Block.Set.Page.IsArchived.Response.Error")
	proto.RegisterType((*RpcBlockSetLatex)(nil), "anytype.Rpc.Block.Set.Latex")
	proto.RegisterType((*RpcBlockSetLatexText)(nil), "anytype.Rpc.Block.Set.Latex.Text")
	proto.RegisterType((*RpcBlockSetLatexTextRequest)(nil), "anytype.Rpc.Block.Set.Latex.Text.Request")
	proto.RegisterType((*RpcBlockSetLatexTextResponse)(nil), "anytype.Rpc.Block.Set.Latex.Text.Response")
	proto.RegisterType((*RpcBlockSetLatexTextResponseError)(nil), "anytype.Rpc.Block.Set.Latex.Text.Response.Error")
	proto.RegisterType((*RpcBlockSetText)(nil), "anytype.Rpc.Block.Set.Text")
	proto.RegisterType((*RpcBlockSetTextText)(nil), "anytype.Rpc.Block.Set.Text.Text")
	proto.RegisterType((*RpcBlockSetTextTextRequest)(nil), "anytype.Rpc.Block.Set.Text.Text.Request")
	proto.RegisterType((*RpcBlockSetTextTextResponse)(nil), "anytype.Rpc.Block.Set.Text.Text.Response")
	proto.RegisterType((*RpcBlockSetTextTextResponseError)(nil), "anytype.Rpc.Block.Set.Text.Text.Response.Error")
	proto.RegisterType((*RpcBlockSetTextColor)(nil), "anytype.Rpc.Block.Set.Text.Color")
	proto.RegisterType((*RpcBlockSetTextColorRequest)(nil), "anytype.Rpc.Block.Set.Text.Color.Request")
	proto.RegisterType((*RpcBlockSetTextColorResponse)(nil), "anytype.Rpc.Block.Set.Text.Color.Response")
	proto.RegisterType((*RpcBlockSetTextColorResponseError)(nil), "anytype.Rpc.Block.Set.Text.Color.Response.Error")
	proto.RegisterType((*RpcBlockSetTextStyle)(nil), "anytype.Rpc.Block.Set.Text.Style")
	proto.RegisterType((*RpcBlockSetTextStyleRequest)(nil), "anytype.Rpc.Block.Set.Text.Style.Request")
	proto.RegisterType((*RpcBlockSetTextStyleResponse)(nil), "anytype.Rpc.Block.Set.Text.Style.Response")
	proto.RegisterType((*RpcBlockSetTextStyleResponseError)(nil), "anytype.Rpc.Block.Set.Text.Style.Response.Error")
	proto.RegisterType((*RpcBlockSetTextChecked)(nil), "anytype.Rpc.Block.Set.Text.Checked")
	proto.RegisterType((*RpcBlockSetTextCheckedRequest)(nil), "anytype.Rpc.Block.Set.Text.Checked.Request")
	proto.RegisterType((*RpcBlockSetTextCheckedResponse)(nil), "anytype.Rpc.Block.Set.Text.Checked.Response")
	proto.RegisterType((*RpcBlockSetTextCheckedResponseError)(nil), "anytype.Rpc.Block.Set.Text.Checked.Response.Error")
	proto.RegisterType((*RpcBlockSetTextIcon)(nil), "anytype.Rpc.Block.Set.Text.Icon")
	proto.RegisterType((*RpcBlockSetTextIconRequest)(nil), "anytype.Rpc.Block.Set.Text.Icon.Request")
	proto.RegisterType((*RpcBlockSetTextIconResponse)(nil), "anytype.Rpc.Block.Set.Text.Icon.Response")
	proto.RegisterType((*RpcBlockSetTextIconResponseError)(nil), "anytype.Rpc.Block.Set.Text.Icon.Response.Error")
	proto.RegisterType((*RpcBlockSetFile)(nil), "anytype.Rpc.Block.Set.File")
	proto.RegisterType((*RpcBlockSetFileName)(nil), "anytype.Rpc.Block.Set.File.Name")
	proto.RegisterType((*RpcBlockSetFileNameRequest)(nil), "anytype.Rpc.Block.Set.File.Name.Request")
	proto.RegisterType((*RpcBlockSetFileNameResponse)(nil), "anytype.Rpc.Block.Set.File.Name.Response")
	proto.RegisterType((*RpcBlockSetFileNameResponseError)(nil), "anytype.Rpc.Block.Set.File.Name.Response.Error")
	proto.RegisterType((*RpcBlockSetImage)(nil), "anytype.Rpc.Block.Set.Image")
	proto.RegisterType((*RpcBlockSetImageName)(nil), "anytype.Rpc.Block.Set.Image.Name")
	proto.RegisterType((*RpcBlockSetImageNameRequest)(nil), "anytype.Rpc.Block.Set.Image.Name.Request")
	proto.RegisterType((*RpcBlockSetImageNameResponse)(nil), "anytype.Rpc.Block.Set.Image.Name.Response")
	proto.RegisterType((*RpcBlockSetImageNameResponseError)(nil), "anytype.Rpc.Block.Set.Image.Name.Response.Error")
	proto.RegisterType((*RpcBlockSetImageWidth)(nil), "anytype.Rpc.Block.Set.Image.Width")
	proto.RegisterType((*RpcBlockSetImageWidthRequest)(nil), "anytype.Rpc.Block.Set.Image.Width.Request")
	proto.RegisterType((*RpcBlockSetImageWidthResponse)(nil), "anytype.Rpc.Block.Set.Image.Width.Response")
	proto.RegisterType((*RpcBlockSetImageWidthResponseError)(nil), "anytype.Rpc.Block.Set.Image.Width.Response.Error")
	proto.RegisterType((*RpcBlockSetVideo)(nil), "anytype.Rpc.Block.Set.Video")
	proto.RegisterType((*RpcBlockSetVideoName)(nil), "anytype.Rpc.Block.Set.Video.Name")
	proto.RegisterType((*RpcBlockSetVideoNameRequest)(nil), "anytype.Rpc.Block.Set.Video.Name.Request")
	proto.RegisterType((*RpcBlockSetVideoNameResponse)(nil), "anytype.Rpc.Block.Set.Video.Name.Response")
	proto.RegisterType((*RpcBlockSetVideoNameResponseError)(nil), "anytype.Rpc.Block.Set.Video.Name.Response.Error")
	proto.RegisterType((*RpcBlockSetVideoWidth)(nil), "anytype.Rpc.Block.Set.Video.Width")
	proto.RegisterType((*RpcBlockSetVideoWidthRequest)(nil), "anytype.Rpc.Block.Set.Video.Width.Request")
	proto.RegisterType((*RpcBlockSetVideoWidthResponse)(nil), "anytype.Rpc.Block.Set.Video.Width.Response")
	proto.RegisterType((*RpcBlockSetVideoWidthResponseError)(nil), "anytype.Rpc.Block.Set.Video.Width.Response.Error")
	proto.RegisterType((*RpcBlockSetLink)(nil), "anytype.Rpc.Block.Set.Link")
	proto.RegisterType((*RpcBlockSetLinkTargetBlockId)(nil), "anytype.Rpc.Block.Set.Link.TargetBlockId")
	proto.RegisterType((*RpcBlockSetLinkTargetBlockIdRequest)(nil), "anytype.Rpc.Block.Set.Link.TargetBlockId.Request")
	proto.RegisterType((*RpcBlockSetLinkTargetBlockIdResponse)(nil), "anytype.Rpc.Block.Set.Link.TargetBlockId.Response")
	proto.RegisterType((*RpcBlockSetLinkTargetBlockIdResponseError)(nil), "anytype.Rpc.Block.Set.Link.TargetBlockId.Response.Error")
	proto.RegisterType((*RpcBlockRelation)(nil), "anytype.Rpc.Block.Relation")
	proto.RegisterType((*RpcBlockRelationSetKey)(nil), "anytype.Rpc.Block.Relation.SetKey")
	proto.RegisterType((*RpcBlockRelationSetKeyRequest)(nil), "anytype.Rpc.Block.Relation.SetKey.Request")
	proto.RegisterType((*RpcBlockRelationSetKeyResponse)(nil), "anytype.Rpc.Block.Relation.SetKey.Response")
	proto.RegisterType((*RpcBlockRelationSetKeyResponseError)(nil), "anytype.Rpc.Block.Relation.SetKey.Response.Error")
	proto.RegisterType((*RpcBlockRelationAdd)(nil), "anytype.Rpc.Block.Relation.Add")
	proto.RegisterType((*RpcBlockRelationAddRequest)(nil), "anytype.Rpc.Block.Relation.Add.Request")
	proto.RegisterType((*RpcBlockRelationAddResponse)(nil), "anytype.Rpc.Block.Relation.Add.Response")
	proto.RegisterType((*RpcBlockRelationAddResponseError)(nil), "anytype.Rpc.Block.Relation.Add.Response.Error")
	proto.RegisterType((*RpcBlockObjectType)(nil), "anytype.Rpc.Block.ObjectType")
	proto.RegisterType((*RpcBlockObjectTypeSet)(nil), "anytype.Rpc.Block.ObjectType.Set")
	proto.RegisterType((*RpcBlockObjectTypeSetRequest)(nil), "anytype.Rpc.Block.ObjectType.Set.Request")
	proto.RegisterType((*RpcBlockObjectTypeSetResponse)(nil), "anytype.Rpc.Block.ObjectType.Set.Response")
	proto.RegisterType((*RpcBlockObjectTypeSetResponseError)(nil), "anytype.Rpc.Block.ObjectType.Set.Response.Error")
	proto.RegisterType((*RpcBlockBookmark)(nil), "anytype.Rpc.Block.Bookmark")
	proto.RegisterType((*RpcBlockBookmarkFetch)(nil), "anytype.Rpc.Block.Bookmark.Fetch")
	proto.RegisterType((*RpcBlockBookmarkFetchRequest)(nil), "anytype.Rpc.Block.Bookmark.Fetch.Request")
	proto.RegisterType((*RpcBlockBookmarkFetchResponse)(nil), "anytype.Rpc.Block.Bookmark.Fetch.Response")
	proto.RegisterType((*RpcBlockBookmarkFetchResponseError)(nil), "anytype.Rpc.Block.Bookmark.Fetch.Response.Error")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetch)(nil), "anytype.Rpc.Block.Bookmark.CreateAndFetch")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetchRequest)(nil), "anytype.Rpc.Block.Bookmark.CreateAndFetch.Request")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetchResponse)(nil), "anytype.Rpc.Block.Bookmark.CreateAndFetch.Response")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetchResponseError)(nil), "anytype.Rpc.Block.Bookmark.CreateAndFetch.Response.Error")
	proto.RegisterType((*RpcBlockFile)(nil), "anytype.Rpc.Block.File")
	proto.RegisterType((*RpcBlockFileCreateAndUpload)(nil), "anytype.Rpc.Block.File.CreateAndUpload")
	proto.RegisterType((*RpcBlockFileCreateAndUploadRequest)(nil), "anytype.Rpc.Block.File.CreateAndUpload.Request")
	proto.RegisterType((*RpcBlockFileCreateAndUploadResponse)(nil), "anytype.Rpc.Block.File.CreateAndUpload.Response")
	proto.RegisterType((*RpcBlockFileCreateAndUploadResponseError)(nil), "anytype.Rpc.Block.File.CreateAndUpload.Response.Error")
	proto.RegisterType((*RpcBlockDataview)(nil), "anytype.Rpc.Block.Dataview")
	proto.RegisterType((*RpcBlockDataviewViewCreate)(nil), "anytype.Rpc.Block.Dataview.ViewCreate")
	proto.RegisterType((*RpcBlockDataviewViewCreateRequest)(nil), "anytype.Rpc.Block.Dataview.ViewCreate.Request")
	proto.RegisterType((*RpcBlockDataviewViewCreateResponse)(nil), "anytype.Rpc.Block.Dataview.ViewCreate.Response")
	proto.RegisterType((*RpcBlockDataviewViewCreateResponseError)(nil), "anytype.Rpc.Block.Dataview.ViewCreate.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewUpdate)(nil), "anytype.Rpc.Block.Dataview.ViewUpdate")
	proto.RegisterType((*RpcBlockDataviewViewUpdateRequest)(nil), "anytype.Rpc.Block.Dataview.ViewUpdate.Request")
	proto.RegisterType((*RpcBlockDataviewViewUpdateResponse)(nil), "anytype.Rpc.Block.Dataview.ViewUpdate.Response")
	proto.RegisterType((*RpcBlockDataviewViewUpdateResponseError)(nil), "anytype.Rpc.Block.Dataview.ViewUpdate.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewDelete)(nil), "anytype.Rpc.Block.Dataview.ViewDelete")
	proto.RegisterType((*RpcBlockDataviewViewDeleteRequest)(nil), "anytype.Rpc.Block.Dataview.ViewDelete.Request")
	proto.RegisterType((*RpcBlockDataviewViewDeleteResponse)(nil), "anytype.Rpc.Block.Dataview.ViewDelete.Response")
	proto.RegisterType((*RpcBlockDataviewViewDeleteResponseError)(nil), "anytype.Rpc.Block.Dataview.ViewDelete.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewSetPosition)(nil), "anytype.Rpc.Block.Dataview.ViewSetPosition")
	proto.RegisterType((*RpcBlockDataviewViewSetPositionRequest)(nil), "anytype.Rpc.Block.Dataview.ViewSetPosition.Request")
	proto.RegisterType((*RpcBlockDataviewViewSetPositionResponse)(nil), "anytype.Rpc.Block.Dataview.ViewSetPosition.Response")
	proto.RegisterType((*RpcBlockDataviewViewSetPositionResponseError)(nil), "anytype.Rpc.Block.Dataview.ViewSetPosition.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewSetActive)(nil), "anytype.Rpc.Block.Dataview.ViewSetActive")
	proto.RegisterType((*RpcBlockDataviewViewSetActiveRequest)(nil), "anytype.Rpc.Block.Dataview.ViewSetActive.Request")
	proto.RegisterType((*RpcBlockDataviewViewSetActiveResponse)(nil), "anytype.Rpc.Block.Dataview.ViewSetActive.Response")
	proto.RegisterType((*RpcBlockDataviewViewSetActiveResponseError)(nil), "anytype.Rpc.Block.Dataview.ViewSetActive.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRecordUpdate)(nil), "anytype.Rpc.Block.Dataview.RecordUpdate")
	proto.RegisterType((*RpcBlockDataviewRecordUpdateRequest)(nil), "anytype.Rpc.Block.Dataview.RecordUpdate.Request")
	proto.RegisterType((*RpcBlockDataviewRecordUpdateResponse)(nil), "anytype.Rpc.Block.Dataview.RecordUpdate.Response")
	proto.RegisterType((*RpcBlockDataviewRecordUpdateResponseError)(nil), "anytype.Rpc.Block.Dataview.RecordUpdate.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRecordDelete)(nil), "anytype.Rpc.Block.Dataview.RecordDelete")
	proto.RegisterType((*RpcBlockDataviewRecordDeleteRequest)(nil), "anytype.Rpc.Block.Dataview.RecordDelete.Request")
	proto.RegisterType((*RpcBlockDataviewRecordDeleteResponse)(nil), "anytype.Rpc.Block.Dataview.RecordDelete.Response")
	proto.RegisterType((*RpcBlockDataviewRecordDeleteResponseError)(nil), "anytype.Rpc.Block.Dataview.RecordDelete.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRecordCreate)(nil), "anytype.Rpc.Block.Dataview.RecordCreate")
	proto.RegisterType((*RpcBlockDataviewRecordCreateRequest)(nil), "anytype.Rpc.Block.Dataview.RecordCreate.Request")
	proto.RegisterType((*RpcBlockDataviewRecordCreateResponse)(nil), "anytype.Rpc.Block.Dataview.RecordCreate.Response")
	proto.RegisterType((*RpcBlockDataviewRecordCreateResponseError)(nil), "anytype.Rpc.Block.Dataview.RecordCreate.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelationAdd)(nil), "anytype.Rpc.Block.Dataview.RelationAdd")
	proto.RegisterType((*RpcBlockDataviewRelationAddRequest)(nil), "anytype.Rpc.Block.Dataview.RelationAdd.Request")
	proto.RegisterType((*RpcBlockDataviewRelationAddResponse)(nil), "anytype.Rpc.Block.Dataview.RelationAdd.Response")
	proto.RegisterType((*RpcBlockDataviewRelationAddResponseError)(nil), "anytype.Rpc.Block.Dataview.RelationAdd.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelationUpdate)(nil), "anytype.Rpc.Block.Dataview.RelationUpdate")
	proto.RegisterType((*RpcBlockDataviewRelationUpdateRequest)(nil), "anytype.Rpc.Block.Dataview.RelationUpdate.Request")
	proto.RegisterType((*RpcBlockDataviewRelationUpdateResponse)(nil), "anytype.Rpc.Block.Dataview.RelationUpdate.Response")
	proto.RegisterType((*RpcBlockDataviewRelationUpdateResponseError)(nil), "anytype.Rpc.Block.Dataview.RelationUpdate.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelationDelete)(nil), "anytype.Rpc.Block.Dataview.RelationDelete")
	proto.RegisterType((*RpcBlockDataviewRelationDeleteRequest)(nil), "anytype.Rpc.Block.Dataview.RelationDelete.Request")
	proto.RegisterType((*RpcBlockDataviewRelationDeleteResponse)(nil), "anytype.Rpc.Block.Dataview.RelationDelete.Response")
	proto.RegisterType((*RpcBlockDataviewRelationDeleteResponseError)(nil), "anytype.Rpc.Block.Dataview.RelationDelete.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionAdd)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionAdd")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionAddRequest)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionAdd.Request")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionAddResponse)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionAdd.Response")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionAddResponseError)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionAdd.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionUpdate)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionUpdate")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionUpdateRequest)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionUpdate.Request")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionUpdateResponse)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionUpdate.Response")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionUpdateResponseError)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionUpdate.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionDelete)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionDelete")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionDeleteRequest)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionDelete.Request")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionDeleteResponse)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionDelete.Response")
	proto.RegisterType((*RpcBlockDataviewRecordRelationOptionDeleteResponseError)(nil), "anytype.Rpc.Block.Dataview.RecordRelationOptionDelete.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailable)(nil), "anytype.Rpc.Block.Dataview.RelationListAvailable")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailableRequest)(nil), "anytype.Rpc.Block.Dataview.RelationListAvailable.Request")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailableResponse)(nil), "anytype.Rpc.Block.Dataview.RelationListAvailable.Response")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailableResponseError)(nil), "anytype.Rpc.Block.Dataview.RelationListAvailable.Response.Error")
	proto.RegisterType((*RpcBlockDataviewSetSource)(nil), "anytype.Rpc.Block.Dataview.SetSource")
	proto.RegisterType((*RpcBlockDataviewSetSourceRequest)(nil), "anytype.Rpc.Block.Dataview.SetSource.Request")
	proto.RegisterType((*RpcBlockDataviewSetSourceResponse)(nil), "anytype.Rpc.Block.Dataview.SetSource.Response")
	proto.RegisterType((*RpcBlockDataviewSetSourceResponseError)(nil), "anytype.Rpc.Block.Dataview.SetSource.Response.Error")
	proto.RegisterType((*RpcBlockGet)(nil), "anytype.Rpc.Block.Get")
	proto.RegisterType((*RpcBlockGetMarks)(nil), "anytype.Rpc.Block.Get.Marks")
	proto.RegisterType((*RpcBlockGetMarksRequest)(nil), "anytype.Rpc.Block.Get.Marks.Request")
	proto.RegisterType((*RpcBlockGetMarksResponse)(nil), "anytype.Rpc.Block.Get.Marks.Response")
	proto.RegisterType((*RpcBlockGetMarksResponseError)(nil), "anytype.Rpc.Block.Get.Marks.Response.Error")
	proto.RegisterType((*RpcBlockUndoRedoCounter)(nil), "anytype.Rpc.Block.UndoRedoCounter")
	proto.RegisterType((*RpcBlockUndo)(nil), "anytype.Rpc.Block.Undo")
	proto.RegisterType((*RpcBlockUndoRequest)(nil), "anytype.Rpc.Block.Undo.Request")
	proto.RegisterType((*RpcBlockUndoResponse)(nil), "anytype.Rpc.Block.Undo.Response")
	proto.RegisterType((*RpcBlockUndoResponseError)(nil), "anytype.Rpc.Block.Undo.Response.Error")
	proto.RegisterType((*RpcBlockRedo)(nil), "anytype.Rpc.Block.Redo")
	proto.RegisterType((*RpcBlockRedoRequest)(nil), "anytype.Rpc.Block.Redo.Request")
	proto.RegisterType((*RpcBlockRedoResponse)(nil), "anytype.Rpc.Block.Redo.Response")
	proto.RegisterType((*RpcBlockRedoResponseError)(nil), "anytype.Rpc.Block.Redo.Response.Error")
	proto.RegisterType((*RpcBlockOpen)(nil), "anytype.Rpc.Block.Open")
	proto.RegisterType((*RpcBlockOpenRequest)(nil), "anytype.Rpc.Block.Open.Request")
	proto.RegisterType((*RpcBlockOpenResponse)(nil), "anytype.Rpc.Block.Open.Response")
	proto.RegisterType((*RpcBlockOpenResponseError)(nil), "anytype.Rpc.Block.Open.Response.Error")
	proto.RegisterType((*RpcBlockShow)(nil), "anytype.Rpc.Block.Show")
	proto.RegisterType((*RpcBlockShowRequest)(nil), "anytype.Rpc.Block.Show.Request")
	proto.RegisterType((*RpcBlockShowResponse)(nil), "anytype.Rpc.Block.Show.Response")
	proto.RegisterType((*RpcBlockShowResponseError)(nil), "anytype.Rpc.Block.Show.Response.Error")
	proto.RegisterType((*RpcBlockGetPublicWebURL)(nil), "anytype.Rpc.Block.GetPublicWebURL")
	proto.RegisterType((*RpcBlockGetPublicWebURLRequest)(nil), "anytype.Rpc.Block.GetPublicWebURL.Request")
	proto.RegisterType((*RpcBlockGetPublicWebURLResponse)(nil), "anytype.Rpc.Block.GetPublicWebURL.Response")
	proto.RegisterType((*RpcBlockGetPublicWebURLResponseError)(nil), "anytype.Rpc.Block.GetPublicWebURL.Response.Error")
	proto.RegisterType((*RpcBlockOpenBreadcrumbs)(nil), "anytype.Rpc.Block.OpenBreadcrumbs")
	proto.RegisterType((*RpcBlockOpenBreadcrumbsRequest)(nil), "anytype.Rpc.Block.OpenBreadcrumbs.Request")
	proto.RegisterType((*RpcBlockOpenBreadcrumbsResponse)(nil), "anytype.Rpc.Block.OpenBreadcrumbs.Response")
	proto.RegisterType((*RpcBlockOpenBreadcrumbsResponseError)(nil), "anytype.Rpc.Block.OpenBreadcrumbs.Response.Error")
	proto.RegisterType((*RpcBlockSetBreadcrumbs)(nil), "anytype.Rpc.Block.SetBreadcrumbs")
	proto.RegisterType((*RpcBlockSetBreadcrumbsRequest)(nil), "anytype.Rpc.Block.SetBreadcrumbs.Request")
	proto.RegisterType((*RpcBlockSetBreadcrumbsResponse)(nil), "anytype.Rpc.Block.SetBreadcrumbs.Response")
	proto.RegisterType((*RpcBlockSetBreadcrumbsResponseError)(nil), "anytype.Rpc.Block.SetBreadcrumbs.Response.Error")
	proto.RegisterType((*RpcBlockCreate)(nil), "anytype.Rpc.Block.Create")
	proto.RegisterType((*RpcBlockCreateRequest)(nil), "anytype.Rpc.Block.Create.Request")
	proto.RegisterType((*RpcBlockCreateResponse)(nil), "anytype.Rpc.Block.Create.Response")
	proto.RegisterType((*RpcBlockCreateResponseError)(nil), "anytype.Rpc.Block.Create.Response.Error")
	proto.RegisterType((*RpcBlockCreatePage)(nil), "anytype.Rpc.Block.CreatePage")
	proto.RegisterType((*RpcBlockCreatePageRequest)(nil), "anytype.Rpc.Block.CreatePage.Request")
	proto.RegisterType((*RpcBlockCreatePageResponse)(nil), "anytype.Rpc.Block.CreatePage.Response")
	proto.RegisterType((*RpcBlockCreatePageResponseError)(nil), "anytype.Rpc.Block.CreatePage.Response.Error")
	proto.RegisterType((*RpcBlockCreateSet)(nil), "anytype.Rpc.Block.CreateSet")
	proto.RegisterType((*RpcBlockCreateSetRequest)(nil), "anytype.Rpc.Block.CreateSet.Request")
	proto.RegisterType((*RpcBlockCreateSetResponse)(nil), "anytype.Rpc.Block.CreateSet.Response")
	proto.RegisterType((*RpcBlockCreateSetResponseError)(nil), "anytype.Rpc.Block.CreateSet.Response.Error")
	proto.RegisterType((*RpcBlockUnlink)(nil), "anytype.Rpc.Block.Unlink")
	proto.RegisterType((*RpcBlockUnlinkRequest)(nil), "anytype.Rpc.Block.Unlink.Request")
	proto.RegisterType((*RpcBlockUnlinkResponse)(nil), "anytype.Rpc.Block.Unlink.Response")
	proto.RegisterType((*RpcBlockUnlinkResponseError)(nil), "anytype.Rpc.Block.Unlink.Response.Error")
	proto.RegisterType((*RpcBlockClose)(nil), "anytype.Rpc.Block.Close")
	proto.RegisterType((*RpcBlockCloseRequest)(nil), "anytype.Rpc.Block.Close.Request")
	proto.RegisterType((*RpcBlockCloseResponse)(nil), "anytype.Rpc.Block.Close.Response")
	proto.RegisterType((*RpcBlockCloseResponseError)(nil), "anytype.Rpc.Block.Close.Response.Error")
	proto.RegisterType((*RpcWorkspace)(nil), "anytype.Rpc.Workspace")
	proto.RegisterType((*RpcWorkspaceGetCurrent)(nil), "anytype.Rpc.Workspace.GetCurrent")
	proto.RegisterType((*RpcWorkspaceGetCurrentRequest)(nil), "anytype.Rpc.Workspace.GetCurrent.Request")
	proto.RegisterType((*RpcWorkspaceGetCurrentResponse)(nil), "anytype.Rpc.Workspace.GetCurrent.Response")
	proto.RegisterType((*RpcWorkspaceGetCurrentResponseError)(nil), "anytype.Rpc.Workspace.GetCurrent.Response.Error")
	proto.RegisterType((*RpcWorkspaceGetAll)(nil), "anytype.Rpc.Workspace.GetAll")
	proto.RegisterType((*RpcWorkspaceGetAllRequest)(nil), "anytype.Rpc.Workspace.GetAll.Request")
	proto.RegisterType((*RpcWorkspaceGetAllResponse)(nil), "anytype.Rpc.Workspace.GetAll.Response")
	proto.RegisterType((*RpcWorkspaceGetAllResponseError)(nil), "anytype.Rpc.Workspace.GetAll.Response.Error")
	proto.RegisterType((*RpcWorkspaceCreate)(nil), "anytype.Rpc.Workspace.Create")
	proto.RegisterType((*RpcWorkspaceCreateRequest)(nil), "anytype.Rpc.Workspace.Create.Request")
	proto.RegisterType((*RpcWorkspaceCreateResponse)(nil), "anytype.Rpc.Workspace.Create.Response")
	proto.RegisterType((*RpcWorkspaceCreateResponseError)(nil), "anytype.Rpc.Workspace.Create.Response.Error")
	proto.RegisterType((*RpcWorkspaceSetIsHighlighted)(nil), "anytype.Rpc.Workspace.SetIsHighlighted")
	proto.RegisterType((*RpcWorkspaceSetIsHighlightedRequest)(nil), "anytype.Rpc.Workspace.SetIsHighlighted.Request")
	proto.RegisterType((*RpcWorkspaceSetIsHighlightedResponse)(nil), "anytype.Rpc.Workspace.SetIsHighlighted.Response")
	proto.RegisterType((*RpcWorkspaceSetIsHighlightedResponseError)(nil), "anytype.Rpc.Workspace.SetIsHighlighted.Response.Error")
	proto.RegisterType((*RpcWorkspaceSelect)(nil), "anytype.Rpc.Workspace.Select")
	proto.RegisterType((*RpcWorkspaceSelectRequest)(nil), "anytype.Rpc.Workspace.Select.Request")
	proto.RegisterType((*RpcWorkspaceSelectResponse)(nil), "anytype.Rpc.Workspace.Select.Response")
	proto.RegisterType((*RpcWorkspaceSelectResponseError)(nil), "anytype.Rpc.Workspace.Select.Response.Error")
	proto.RegisterType((*RpcWallet)(nil), "anytype.Rpc.Wallet")
	proto.RegisterType((*RpcWalletCreate)(nil), "anytype.Rpc.Wallet.Create")
	proto.RegisterType((*RpcWalletCreateRequest)(nil), "anytype.Rpc.Wallet.Create.Request")
	proto.RegisterType((*RpcWalletCreateResponse)(nil), "anytype.Rpc.Wallet.Create.Response")
	proto.RegisterType((*RpcWalletCreateResponseError)(nil), "anytype.Rpc.Wallet.Create.Response.Error")
	proto.RegisterType((*RpcWalletRecover)(nil), "anytype.Rpc.Wallet.Recover")
	proto.RegisterType((*RpcWalletRecoverRequest)(nil), "anytype.Rpc.Wallet.Recover.Request")
	proto.RegisterType((*RpcWalletRecoverResponse)(nil), "anytype.Rpc.Wallet.Recover.Response")
	proto.RegisterType((*RpcWalletRecoverResponseError)(nil), "anytype.Rpc.Wallet.Recover.Response.Error")
	proto.RegisterType((*RpcWalletConvert)(nil), "anytype.Rpc.Wallet.Convert")
	proto.RegisterType((*RpcWalletConvertRequest)(nil), "anytype.Rpc.Wallet.Convert.Request")
	proto.RegisterType((*RpcWalletConvertResponse)(nil), "anytype.Rpc.Wallet.Convert.Response")
	proto.RegisterType((*RpcWalletConvertResponseError)(nil), "anytype.Rpc.Wallet.Convert.Response.Error")
	proto.RegisterType((*RpcAccount)(nil), "anytype.Rpc.Account")
	proto.RegisterType((*RpcAccountConfig)(nil), "anytype.Rpc.Account.Config")
	proto.RegisterType((*RpcAccountCreate)(nil), "anytype.Rpc.Account.Create")
	proto.RegisterType((*RpcAccountCreateRequest)(nil), "anytype.Rpc.Account.Create.Request")
	proto.RegisterType((*RpcAccountCreateResponse)(nil), "anytype.Rpc.Account.Create.Response")
	proto.RegisterType((*RpcAccountCreateResponseError)(nil), "anytype.Rpc.Account.Create.Response.Error")
	proto.RegisterType((*RpcAccountRecover)(nil), "anytype.Rpc.Account.Recover")
	proto.RegisterType((*RpcAccountRecoverRequest)(nil), "anytype.Rpc.Account.Recover.Request")
	proto.RegisterType((*RpcAccountRecoverResponse)(nil), "anytype.Rpc.Account.Recover.Response")
	proto.RegisterType((*RpcAccountRecoverResponseError)(nil), "anytype.Rpc.Account.Recover.Response.Error")
	proto.RegisterType((*RpcAccountSelect)(nil), "anytype.Rpc.Account.Select")
	proto.RegisterType((*RpcAccountSelectRequest)(nil), "anytype.Rpc.Account.Select.Request")
	proto.RegisterType((*RpcAccountSelectResponse)(nil), "anytype.Rpc.Account.Select.Response")
	proto.RegisterType((*RpcAccountSelectResponseError)(nil), "anytype.Rpc.Account.Select.Response.Error")
	proto.RegisterType((*RpcAccountStop)(nil), "anytype.Rpc.Account.Stop")
	proto.RegisterType((*RpcAccountStopRequest)(nil), "anytype.Rpc.Account.Stop.Request")
	proto.RegisterType((*RpcAccountStopResponse)(nil), "anytype.Rpc.Account.Stop.Response")
	proto.RegisterType((*RpcAccountStopResponseError)(nil), "anytype.Rpc.Account.Stop.Response.Error")
	proto.RegisterType((*RpcLog)(nil), "anytype.Rpc.Log")
	proto.RegisterType((*RpcLogSend)(nil), "anytype.Rpc.Log.Send")
	proto.RegisterType((*RpcLogSendRequest)(nil), "anytype.Rpc.Log.Send.Request")
	proto.RegisterType((*RpcLogSendResponse)(nil), "anytype.Rpc.Log.Send.Response")
	proto.RegisterType((*RpcLogSendResponseError)(nil), "anytype.Rpc.Log.Send.Response.Error")
	proto.RegisterType((*RpcVersion)(nil), "anytype.Rpc.Version")
	proto.RegisterType((*RpcVersionGet)(nil), "anytype.Rpc.Version.Get")
	proto.RegisterType((*RpcVersionGetRequest)(nil), "anytype.Rpc.Version.Get.Request")
	proto.RegisterType((*RpcVersionGetResponse)(nil), "anytype.Rpc.Version.Get.Response")
	proto.RegisterType((*RpcVersionGetResponseError)(nil), "anytype.Rpc.Version.Get.Response.Error")
	proto.RegisterType((*RpcFile)(nil), "anytype.Rpc.File")
	proto.RegisterType((*RpcFileOffload)(nil), "anytype.Rpc.File.Offload")
	proto.RegisterType((*RpcFileOffloadRequest)(nil), "anytype.Rpc.File.Offload.Request")
	proto.RegisterType((*RpcFileOffloadResponse)(nil), "anytype.Rpc.File.Offload.Response")
	proto.RegisterType((*RpcFileOffloadResponseError)(nil), "anytype.Rpc.File.Offload.Response.Error")
	proto.RegisterType((*RpcFileList)(nil), "anytype.Rpc.FileList")
	proto.RegisterType((*RpcFileListOffload)(nil), "anytype.Rpc.FileList.Offload")
	proto.RegisterType((*RpcFileListOffloadRequest)(nil), "anytype.Rpc.FileList.Offload.Request")
	proto.RegisterType((*RpcFileListOffloadResponse)(nil), "anytype.Rpc.FileList.Offload.Response")
	proto.RegisterType((*RpcFileListOffloadResponseError)(nil), "anytype.Rpc.FileList.Offload.Response.Error")
	proto.RegisterType((*RpcShutdown)(nil), "anytype.Rpc.Shutdown")
	proto.RegisterType((*RpcShutdownRequest)(nil), "anytype.Rpc.Shutdown.Request")
	proto.RegisterType((*RpcShutdownResponse)(nil), "anytype.Rpc.Shutdown.Response")
	proto.RegisterType((*RpcShutdownResponseError)(nil), "anytype.Rpc.Shutdown.Response.Error")
	proto.RegisterType((*RpcConfig)(nil), "anytype.Rpc.Config")
	proto.RegisterType((*RpcConfigGet)(nil), "anytype.Rpc.Config.Get")
	proto.RegisterType((*RpcConfigGetRequest)(nil), "anytype.Rpc.Config.Get.Request")
	proto.RegisterType((*RpcConfigGetResponse)(nil), "anytype.Rpc.Config.Get.Response")
	proto.RegisterType((*RpcConfigGetResponseError)(nil), "anytype.Rpc.Config.Get.Response.Error")
	proto.RegisterType((*RpcPing)(nil), "anytype.Rpc.Ping")
	proto.RegisterType((*RpcPingRequest)(nil), "anytype.Rpc.Ping.Request")
	proto.RegisterType((*RpcPingResponse)(nil), "anytype.Rpc.Ping.Response")
	proto.RegisterType((*RpcPingResponseError)(nil), "anytype.Rpc.Ping.Response.Error")
	proto.RegisterType((*RpcProcess)(nil), "anytype.Rpc.Process")
	proto.RegisterType((*RpcProcessCancel)(nil), "anytype.Rpc.Process.Cancel")
	proto.RegisterType((*RpcProcessCancelRequest)(nil), "anytype.Rpc.Process.Cancel.Request")
	proto.RegisterType((*RpcProcessCancelResponse)(nil), "anytype.Rpc.Process.Cancel.Response")
	proto.RegisterType((*RpcProcessCancelResponseError)(nil), "anytype.Rpc.Process.Cancel.Response.Error")
	proto.RegisterType((*RpcLinkPreview)(nil), "anytype.Rpc.LinkPreview")
	proto.RegisterType((*RpcLinkPreviewRequest)(nil), "anytype.Rpc.LinkPreview.Request")
	proto.RegisterType((*RpcLinkPreviewResponse)(nil), "anytype.Rpc.LinkPreview.Response")
	proto.RegisterType((*RpcLinkPreviewResponseError)(nil), "anytype.Rpc.LinkPreview.Response.Error")
	proto.RegisterType((*RpcUploadFile)(nil), "anytype.Rpc.UploadFile")
	proto.RegisterType((*RpcUploadFileRequest)(nil), "anytype.Rpc.UploadFile.Request")
	proto.RegisterType((*RpcUploadFileResponse)(nil), "anytype.Rpc.UploadFile.Response")
	proto.RegisterType((*RpcUploadFileResponseError)(nil), "anytype.Rpc.UploadFile.Response.Error")
	proto.RegisterType((*RpcDownloadFile)(nil), "anytype.Rpc.DownloadFile")
	proto.RegisterType((*RpcDownloadFileRequest)(nil), "anytype.Rpc.DownloadFile.Request")
	proto.RegisterType((*RpcDownloadFileResponse)(nil), "anytype.Rpc.DownloadFile.Response")
	proto.RegisterType((*RpcDownloadFileResponseError)(nil), "anytype.Rpc.DownloadFile.Response.Error")
	proto.RegisterType((*RpcNavigation)(nil), "anytype.Rpc.Navigation")
	proto.RegisterType((*RpcNavigationListObjects)(nil), "anytype.Rpc.Navigation.ListObjects")
	proto.RegisterType((*RpcNavigationListObjectsRequest)(nil), "anytype.Rpc.Navigation.ListObjects.Request")
	proto.RegisterType((*RpcNavigationListObjectsResponse)(nil), "anytype.Rpc.Navigation.ListObjects.Response")
	proto.RegisterType((*RpcNavigationListObjectsResponseError)(nil), "anytype.Rpc.Navigation.ListObjects.Response.Error")
	proto.RegisterType((*RpcNavigationGetObjectInfoWithLinks)(nil), "anytype.Rpc.Navigation.GetObjectInfoWithLinks")
	proto.RegisterType((*RpcNavigationGetObjectInfoWithLinksRequest)(nil), "anytype.Rpc.Navigation.GetObjectInfoWithLinks.Request")
	proto.RegisterType((*RpcNavigationGetObjectInfoWithLinksResponse)(nil), "anytype.Rpc.Navigation.GetObjectInfoWithLinks.Response")
	proto.RegisterType((*RpcNavigationGetObjectInfoWithLinksResponseError)(nil), "anytype.Rpc.Navigation.GetObjectInfoWithLinks.Response.Error")
	proto.RegisterType((*RpcHistory)(nil), "anytype.Rpc.History")
	proto.RegisterType((*RpcHistoryVersions)(nil), "anytype.Rpc.History.Versions")
	proto.RegisterType((*RpcHistoryVersionsVersion)(nil), "anytype.Rpc.History.Versions.Version")
	proto.RegisterType((*RpcHistoryVersionsRequest)(nil), "anytype.Rpc.History.Versions.Request")
	proto.RegisterType((*RpcHistoryVersionsResponse)(nil), "anytype.Rpc.History.Versions.Response")
	proto.RegisterType((*RpcHistoryVersionsResponseError)(nil), "anytype.Rpc.History.Versions.Response.Error")
	proto.RegisterType((*RpcHistoryShow)(nil), "anytype.Rpc.History.Show")
	proto.RegisterType((*RpcHistoryShowRequest)(nil), "anytype.Rpc.History.Show.Request")
	proto.RegisterType((*RpcHistoryShowResponse)(nil), "anytype.Rpc.History.Show.Response")
	proto.RegisterType((*RpcHistoryShowResponseError)(nil), "anytype.Rpc.History.Show.Response.Error")
	proto.RegisterType((*RpcHistorySetVersion)(nil), "anytype.Rpc.History.SetVersion")
	proto.RegisterType((*RpcHistorySetVersionRequest)(nil), "anytype.Rpc.History.SetVersion.Request")
	proto.RegisterType((*RpcHistorySetVersionResponse)(nil), "anytype.Rpc.History.SetVersion.Response")
	proto.RegisterType((*RpcHistorySetVersionResponseError)(nil), "anytype.Rpc.History.SetVersion.Response.Error")
	proto.RegisterType((*RpcPage)(nil), "anytype.Rpc.Page")
	proto.RegisterType((*RpcPageCreate)(nil), "anytype.Rpc.Page.Create")
	proto.RegisterType((*RpcPageCreateRequest)(nil), "anytype.Rpc.Page.Create.Request")
	proto.RegisterType((*RpcPageCreateResponse)(nil), "anytype.Rpc.Page.Create.Response")
	proto.RegisterType((*RpcPageCreateResponseError)(nil), "anytype.Rpc.Page.Create.Response.Error")
	proto.RegisterType((*RpcSet)(nil), "anytype.Rpc.Set")
	proto.RegisterType((*RpcSetCreate)(nil), "anytype.Rpc.Set.Create")
	proto.RegisterType((*RpcSetCreateRequest)(nil), "anytype.Rpc.Set.Create.Request")
	proto.RegisterType((*RpcSetCreateResponse)(nil), "anytype.Rpc.Set.Create.Response")
	proto.RegisterType((*RpcSetCreateResponseError)(nil), "anytype.Rpc.Set.Create.Response.Error")
	proto.RegisterType((*RpcObjectType)(nil), "anytype.Rpc.ObjectType")
	proto.RegisterType((*RpcObjectTypeList)(nil), "anytype.Rpc.ObjectType.List")
	proto.RegisterType((*RpcObjectTypeListRequest)(nil), "anytype.Rpc.ObjectType.List.Request")
	proto.RegisterType((*RpcObjectTypeListResponse)(nil), "anytype.Rpc.ObjectType.List.Response")
	proto.RegisterType((*RpcObjectTypeListResponseError)(nil), "anytype.Rpc.ObjectType.List.Response.Error")
	proto.RegisterType((*RpcObjectTypeCreate)(nil), "anytype.Rpc.ObjectType.Create")
	proto.RegisterType((*RpcObjectTypeCreateRequest)(nil), "anytype.Rpc.ObjectType.Create.Request")
	proto.RegisterType((*RpcObjectTypeCreateResponse)(nil), "anytype.Rpc.ObjectType.Create.Response")
	proto.RegisterType((*RpcObjectTypeCreateResponseError)(nil), "anytype.Rpc.ObjectType.Create.Response.Error")
	proto.RegisterType((*RpcObjectTypeRelation)(nil), "anytype.Rpc.ObjectType.Relation")
	proto.RegisterType((*RpcObjectTypeRelationAdd)(nil), "anytype.Rpc.ObjectType.Relation.Add")
	proto.RegisterType((*RpcObjectTypeRelationAddRequest)(nil), "anytype.Rpc.ObjectType.Relation.Add.Request")
	proto.RegisterType((*RpcObjectTypeRelationAddResponse)(nil), "anytype.Rpc.ObjectType.Relation.Add.Response")
	proto.RegisterType((*RpcObjectTypeRelationAddResponseError)(nil), "anytype.Rpc.ObjectType.Relation.Add.Response.Error")
	proto.RegisterType((*RpcObjectTypeRelationRemove)(nil), "anytype.Rpc.ObjectType.Relation.Remove")
	proto.RegisterType((*RpcObjectTypeRelationRemoveRequest)(nil), "anytype.Rpc.ObjectType.Relation.Remove.Request")
	proto.RegisterType((*RpcObjectTypeRelationRemoveResponse)(nil), "anytype.Rpc.ObjectType.Relation.Remove.Response")
	proto.RegisterType((*RpcObjectTypeRelationRemoveResponseError)(nil), "anytype.Rpc.ObjectType.Relation.Remove.Response.Error")
	proto.RegisterType((*RpcObjectTypeRelationUpdate)(nil), "anytype.Rpc.ObjectType.Relation.Update")
	proto.RegisterType((*RpcObjectTypeRelationUpdateRequest)(nil), "anytype.Rpc.ObjectType.Relation.Update.Request")
	proto.RegisterType((*RpcObjectTypeRelationUpdateResponse)(nil), "anytype.Rpc.ObjectType.Relation.Update.Response")
	proto.RegisterType((*RpcObjectTypeRelationUpdateResponseError)(nil), "anytype.Rpc.ObjectType.Relation.Update.Response.Error")
	proto.RegisterType((*RpcObjectTypeRelationList)(nil), "anytype.Rpc.ObjectType.Relation.List")
	proto.RegisterType((*RpcObjectTypeRelationListRequest)(nil), "anytype.Rpc.ObjectType.Relation.List.Request")
	proto.RegisterType((*RpcObjectTypeRelationListResponse)(nil), "anytype.Rpc.ObjectType.Relation.List.Response")
	proto.RegisterType((*RpcObjectTypeRelationListResponseError)(nil), "anytype.Rpc.ObjectType.Relation.List.Response.Error")
	proto.RegisterType((*RpcObject)(nil), "anytype.Rpc.Object")
	proto.RegisterType((*RpcObjectShareByLink)(nil), "anytype.Rpc.Object.ShareByLink")
	proto.RegisterType((*RpcObjectShareByLinkRequest)(nil), "anytype.Rpc.Object.ShareByLink.Request")
	proto.RegisterType((*RpcObjectShareByLinkResponse)(nil), "anytype.Rpc.Object.ShareByLink.Response")
	proto.RegisterType((*RpcObjectShareByLinkResponseError)(nil), "anytype.Rpc.Object.ShareByLink.Response.Error")
	proto.RegisterType((*RpcObjectAddWithObjectId)(nil), "anytype.Rpc.Object.AddWithObjectId")
	proto.RegisterType((*RpcObjectAddWithObjectIdRequest)(nil), "anytype.Rpc.Object.AddWithObjectId.Request")
	proto.RegisterType((*RpcObjectAddWithObjectIdResponse)(nil), "anytype.Rpc.Object.AddWithObjectId.Response")
	proto.RegisterType((*RpcObjectAddWithObjectIdResponseError)(nil), "anytype.Rpc.Object.AddWithObjectId.Response.Error")
	proto.RegisterType((*RpcObjectRelationAdd)(nil), "anytype.Rpc.Object.RelationAdd")
	proto.RegisterType((*RpcObjectRelationAddRequest)(nil), "anytype.Rpc.Object.RelationAdd.Request")
	proto.RegisterType((*RpcObjectRelationAddResponse)(nil), "anytype.Rpc.Object.RelationAdd.Response")
	proto.RegisterType((*RpcObjectRelationAddResponseError)(nil), "anytype.Rpc.Object.RelationAdd.Response.Error")
	proto.RegisterType((*RpcObjectRelationUpdate)(nil), "anytype.Rpc.Object.RelationUpdate")
	proto.RegisterType((*RpcObjectRelationUpdateRequest)(nil), "anytype.Rpc.Object.RelationUpdate.Request")
	proto.RegisterType((*RpcObjectRelationUpdateResponse)(nil), "anytype.Rpc.Object.RelationUpdate.Response")
	proto.RegisterType((*RpcObjectRelationUpdateResponseError)(nil), "anytype.Rpc.Object.RelationUpdate.Response.Error")
	proto.RegisterType((*RpcObjectRelationDelete)(nil), "anytype.Rpc.Object.RelationDelete")
	proto.RegisterType((*RpcObjectRelationDeleteRequest)(nil), "anytype.Rpc.Object.RelationDelete.Request")
	proto.RegisterType((*RpcObjectRelationDeleteResponse)(nil), "anytype.Rpc.Object.RelationDelete.Response")
	proto.RegisterType((*RpcObjectRelationDeleteResponseError)(nil), "anytype.Rpc.Object.RelationDelete.Response.Error")
	proto.RegisterType((*RpcObjectRelationOptionAdd)(nil), "anytype.Rpc.Object.RelationOptionAdd")
	proto.RegisterType((*RpcObjectRelationOptionAddRequest)(nil), "anytype.Rpc.Object.RelationOptionAdd.Request")
	proto.RegisterType((*RpcObjectRelationOptionAddResponse)(nil), "anytype.Rpc.Object.RelationOptionAdd.Response")
	proto.RegisterType((*RpcObjectRelationOptionAddResponseError)(nil), "anytype.Rpc.Object.RelationOptionAdd.Response.Error")
	proto.RegisterType((*RpcObjectRelationOptionUpdate)(nil), "anytype.Rpc.Object.RelationOptionUpdate")
	proto.RegisterType((*RpcObjectRelationOptionUpdateRequest)(nil), "anytype.Rpc.Object.RelationOptionUpdate.Request")
	proto.RegisterType((*RpcObjectRelationOptionUpdateResponse)(nil), "anytype.Rpc.Object.RelationOptionUpdate.Response")
	proto.RegisterType((*RpcObjectRelationOptionUpdateResponseError)(nil), "anytype.Rpc.Object.RelationOptionUpdate.Response.Error")
	proto.RegisterType((*RpcObjectRelationOptionDelete)(nil), "anytype.Rpc.Object.RelationOptionDelete")
	proto.RegisterType((*RpcObjectRelationOptionDeleteRequest)(nil), "anytype.Rpc.Object.RelationOptionDelete.Request")
	proto.RegisterType((*RpcObjectRelationOptionDeleteResponse)(nil), "anytype.Rpc.Object.RelationOptionDelete.Response")
	proto.RegisterType((*RpcObjectRelationOptionDeleteResponseError)(nil), "anytype.Rpc.Object.RelationOptionDelete.Response.Error")
	proto.RegisterType((*RpcObjectRelationListAvailable)(nil), "anytype.Rpc.Object.RelationListAvailable")
	proto.RegisterType((*RpcObjectRelationListAvailableRequest)(nil), "anytype.Rpc.Object.RelationListAvailable.Request")
	proto.RegisterType((*RpcObjectRelationListAvailableResponse)(nil), "anytype.Rpc.Object.RelationListAvailable.Response")
	proto.RegisterType((*RpcObjectRelationListAvailableResponseError)(nil), "anytype.Rpc.Object.RelationListAvailable.Response.Error")
	proto.RegisterType((*RpcObjectSearch)(nil), "anytype.Rpc.Object.Search")
	proto.RegisterType((*RpcObjectSearchRequest)(nil), "anytype.Rpc.Object.Search.Request")
	proto.RegisterType((*RpcObjectSearchResponse)(nil), "anytype.Rpc.Object.Search.Response")
	proto.RegisterType((*RpcObjectSearchResponseError)(nil), "anytype.Rpc.Object.Search.Response.Error")
	proto.RegisterType((*RpcObjectGraph)(nil), "anytype.Rpc.Object.Graph")
	proto.RegisterType((*RpcObjectGraphRequest)(nil), "anytype.Rpc.Object.Graph.Request")
	proto.RegisterType((*RpcObjectGraphNode)(nil), "anytype.Rpc.Object.Graph.Node")
	proto.RegisterType((*RpcObjectGraphEdge)(nil), "anytype.Rpc.Object.Graph.Edge")
	proto.RegisterType((*RpcObjectGraphResponse)(nil), "anytype.Rpc.Object.Graph.Response")
	proto.RegisterType((*RpcObjectGraphResponseError)(nil), "anytype.Rpc.Object.Graph.Response.Error")
	proto.RegisterType((*RpcObjectSearchSubscribe)(nil), "anytype.Rpc.Object.SearchSubscribe")
	proto.RegisterType((*RpcObjectSearchSubscribeRequest)(nil), "anytype.Rpc.Object.SearchSubscribe.Request")
	proto.RegisterType((*RpcObjectSearchSubscribeResponse)(nil), "anytype.Rpc.Object.SearchSubscribe.Response")
	proto.RegisterType((*RpcObjectSearchSubscribeResponseError)(nil), "anytype.Rpc.Object.SearchSubscribe.Response.Error")
	proto.RegisterType((*RpcObjectIdsSubscribe)(nil), "anytype.Rpc.Object.IdsSubscribe")
	proto.RegisterType((*RpcObjectIdsSubscribeRequest)(nil), "anytype.Rpc.Object.IdsSubscribe.Request")
	proto.RegisterType((*RpcObjectIdsSubscribeResponse)(nil), "anytype.Rpc.Object.IdsSubscribe.Response")
	proto.RegisterType((*RpcObjectIdsSubscribeResponseError)(nil), "anytype.Rpc.Object.IdsSubscribe.Response.Error")
	proto.RegisterType((*RpcObjectSearchUnsubscribe)(nil), "anytype.Rpc.Object.SearchUnsubscribe")
	proto.RegisterType((*RpcObjectSearchUnsubscribeRequest)(nil), "anytype.Rpc.Object.SearchUnsubscribe.Request")
	proto.RegisterType((*RpcObjectSearchUnsubscribeResponse)(nil), "anytype.Rpc.Object.SearchUnsubscribe.Response")
	proto.RegisterType((*RpcObjectSearchUnsubscribeResponseError)(nil), "anytype.Rpc.Object.SearchUnsubscribe.Response.Error")
	proto.RegisterType((*RpcObjectSetLayout)(nil), "anytype.Rpc.Object.SetLayout")
	proto.RegisterType((*RpcObjectSetLayoutRequest)(nil), "anytype.Rpc.Object.SetLayout.Request")
	proto.RegisterType((*RpcObjectSetLayoutResponse)(nil), "anytype.Rpc.Object.SetLayout.Response")
	proto.RegisterType((*RpcObjectSetLayoutResponseError)(nil), "anytype.Rpc.Object.SetLayout.Response.Error")
	proto.RegisterType((*RpcObjectSetIsFavorite)(nil), "anytype.Rpc.Object.SetIsFavorite")
	proto.RegisterType((*RpcObjectSetIsFavoriteRequest)(nil), "anytype.Rpc.Object.SetIsFavorite.Request")
	proto.RegisterType((*RpcObjectSetIsFavoriteResponse)(nil), "anytype.Rpc.Object.SetIsFavorite.Response")
	proto.RegisterType((*RpcObjectSetIsFavoriteResponseError)(nil), "anytype.Rpc.Object.SetIsFavorite.Response.Error")
	proto.RegisterType((*RpcObjectSetIsArchived)(nil), "anytype.Rpc.Object.SetIsArchived")
	proto.RegisterType((*RpcObjectSetIsArchivedRequest)(nil), "anytype.Rpc.Object.SetIsArchived.Request")
	proto.RegisterType((*RpcObjectSetIsArchivedResponse)(nil), "anytype.Rpc.Object.SetIsArchived.Response")
	proto.RegisterType((*RpcObjectSetIsArchivedResponseError)(nil), "anytype.Rpc.Object.SetIsArchived.Response.Error")
	proto.RegisterType((*RpcObjectFeaturedRelation)(nil), "anytype.Rpc.Object.FeaturedRelation")
	proto.RegisterType((*RpcObjectFeaturedRelationAdd)(nil), "anytype.Rpc.Object.FeaturedRelation.Add")
	proto.RegisterType((*RpcObjectFeaturedRelationAddRequest)(nil), "anytype.Rpc.Object.FeaturedRelation.Add.Request")
	proto.RegisterType((*RpcObjectFeaturedRelationAddResponse)(nil), "anytype.Rpc.Object.FeaturedRelation.Add.Response")
	proto.RegisterType((*RpcObjectFeaturedRelationAddResponseError)(nil), "anytype.Rpc.Object.FeaturedRelation.Add.Response.Error")
	proto.RegisterType((*RpcObjectFeaturedRelationRemove)(nil), "anytype.Rpc.Object.FeaturedRelation.Remove")
	proto.RegisterType((*RpcObjectFeaturedRelationRemoveRequest)(nil), "anytype.Rpc.Object.FeaturedRelation.Remove.Request")
	proto.RegisterType((*RpcObjectFeaturedRelationRemoveResponse)(nil), "anytype.Rpc.Object.FeaturedRelation.Remove.Response")
	proto.RegisterType((*RpcObjectFeaturedRelationRemoveResponseError)(nil), "anytype.Rpc.Object.FeaturedRelation.Remove.Response.Error")
	proto.RegisterType((*RpcObjectToSet)(nil), "anytype.Rpc.Object.ToSet")
	proto.RegisterType((*RpcObjectToSetRequest)(nil), "anytype.Rpc.Object.ToSet.Request")
	proto.RegisterType((*RpcObjectToSetResponse)(nil), "anytype.Rpc.Object.ToSet.Response")
	proto.RegisterType((*RpcObjectToSetResponseError)(nil), "anytype.Rpc.Object.ToSet.Response.Error")
	proto.RegisterType((*RpcObjectList)(nil), "anytype.Rpc.ObjectList")
	proto.RegisterType((*RpcObjectListDelete)(nil), "anytype.Rpc.ObjectList.Delete")
	proto.RegisterType((*RpcObjectListDeleteRequest)(nil), "anytype.Rpc.ObjectList.Delete.Request")
	proto.RegisterType((*RpcObjectListDeleteResponse)(nil), "anytype.Rpc.ObjectList.Delete.Response")
	proto.RegisterType((*RpcObjectListDeleteResponseError)(nil), "anytype.Rpc.ObjectList.Delete.Response.Error")
	proto.RegisterType((*RpcObjectListSet)(nil), "anytype.Rpc.ObjectList.Set")
	proto.RegisterType((*RpcObjectListSetIsArchived)(nil), "anytype.Rpc.ObjectList.Set.IsArchived")
	proto.RegisterType((*RpcObjectListSetIsArchivedRequest)(nil), "anytype.Rpc.ObjectList.Set.IsArchived.Request")
	proto.RegisterType((*RpcObjectListSetIsArchivedResponse)(nil), "anytype.Rpc.ObjectList.Set.IsArchived.Response")
	proto.RegisterType((*RpcObjectListSetIsArchivedResponseError)(nil), "anytype.Rpc.ObjectList.Set.IsArchived.Response.Error")
	proto.RegisterType((*RpcObjectListSetIsFavorite)(nil), "anytype.Rpc.ObjectList.Set.IsFavorite")
	proto.RegisterType((*RpcObjectListSetIsFavoriteRequest)(nil), "anytype.Rpc.ObjectList.Set.IsFavorite.Request")
	proto.RegisterType((*RpcObjectListSetIsFavoriteResponse)(nil), "anytype.Rpc.ObjectList.Set.IsFavorite.Response")
	proto.RegisterType((*RpcObjectListSetIsFavoriteResponseError)(nil), "anytype.Rpc.ObjectList.Set.IsFavorite.Response.Error")
	proto.RegisterType((*RpcExport)(nil), "anytype.Rpc.Export")
	proto.RegisterType((*RpcExportRequest)(nil), "anytype.Rpc.Export.Request")
	proto.RegisterType((*RpcExportResponse)(nil), "anytype.Rpc.Export.Response")
	proto.RegisterType((*RpcExportResponseError)(nil), "anytype.Rpc.Export.Response.Error")
	proto.RegisterType((*RpcExportWorkspace)(nil), "anytype.Rpc.ExportWorkspace")
	proto.RegisterType((*RpcExportWorkspaceRequest)(nil), "anytype.Rpc.ExportWorkspace.Request")
	proto.RegisterType((*RpcExportWorkspaceResponse)(nil), "anytype.Rpc.ExportWorkspace.Response")
	proto.RegisterType((*RpcExportWorkspaceResponseError)(nil), "anytype.Rpc.ExportWorkspace.Response.Error")
	proto.RegisterType((*RpcExportTemplates)(nil), "anytype.Rpc.ExportTemplates")
	proto.RegisterType((*RpcExportTemplatesRequest)(nil), "anytype.Rpc.ExportTemplates.Request")
	proto.RegisterType((*RpcExportTemplatesResponse)(nil), "anytype.Rpc.ExportTemplates.Response")
	proto.RegisterType((*RpcExportTemplatesResponseError)(nil), "anytype.Rpc.ExportTemplates.Response.Error")
	proto.RegisterType((*RpcExportLocalstore)(nil), "anytype.Rpc.ExportLocalstore")
	proto.RegisterType((*RpcExportLocalstoreRequest)(nil), "anytype.Rpc.ExportLocalstore.Request")
	proto.RegisterType((*RpcExportLocalstoreResponse)(nil), "anytype.Rpc.ExportLocalstore.Response")
	proto.RegisterType((*RpcExportLocalstoreResponseError)(nil), "anytype.Rpc.ExportLocalstore.Response.Error")
	proto.RegisterType((*RpcMakeTemplate)(nil), "anytype.Rpc.MakeTemplate")
	proto.RegisterType((*RpcMakeTemplateRequest)(nil), "anytype.Rpc.MakeTemplate.Request")
	proto.RegisterType((*RpcMakeTemplateResponse)(nil), "anytype.Rpc.MakeTemplate.Response")
	proto.RegisterType((*RpcMakeTemplateResponseError)(nil), "anytype.Rpc.MakeTemplate.Response.Error")
	proto.RegisterType((*RpcMakeTemplateByObjectType)(nil), "anytype.Rpc.MakeTemplateByObjectType")
	proto.RegisterType((*RpcMakeTemplateByObjectTypeRequest)(nil), "anytype.Rpc.MakeTemplateByObjectType.Request")
	proto.RegisterType((*RpcMakeTemplateByObjectTypeResponse)(nil), "anytype.Rpc.MakeTemplateByObjectType.Response")
	proto.RegisterType((*RpcMakeTemplateByObjectTypeResponseError)(nil), "anytype.Rpc.MakeTemplateByObjectType.Response.Error")
	proto.RegisterType((*RpcCloneTemplate)(nil), "anytype.Rpc.CloneTemplate")
	proto.RegisterType((*RpcCloneTemplateRequest)(nil), "anytype.Rpc.CloneTemplate.Request")
	proto.RegisterType((*RpcCloneTemplateResponse)(nil), "anytype.Rpc.CloneTemplate.Response")
	proto.RegisterType((*RpcCloneTemplateResponseError)(nil), "anytype.Rpc.CloneTemplate.Response.Error")
	proto.RegisterType((*RpcObjectDuplicate)(nil), "anytype.Rpc.ObjectDuplicate")
	proto.RegisterType((*RpcObjectDuplicateRequest)(nil), "anytype.Rpc.ObjectDuplicate.Request")
	proto.RegisterType((*RpcObjectDuplicateResponse)(nil), "anytype.Rpc.ObjectDuplicate.Response")
	proto.RegisterType((*RpcObjectDuplicateResponseError)(nil), "anytype.Rpc.ObjectDuplicate.Response.Error")
	proto.RegisterType((*RpcUnsplashSearch)(nil), "anytype.Rpc.UnsplashSearch")
	proto.RegisterType((*RpcUnsplashSearchRequest)(nil), "anytype.Rpc.UnsplashSearch.Request")
	proto.RegisterType((*RpcUnsplashSearchResponse)(nil), "anytype.Rpc.UnsplashSearch.Response")
	proto.RegisterType((*RpcUnsplashSearchResponsePicture)(nil), "anytype.Rpc.UnsplashSearch.Response.Picture")
	proto.RegisterType((*RpcUnsplashSearchResponseError)(nil), "anytype.Rpc.UnsplashSearch.Response.Error")
	proto.RegisterType((*RpcUnsplashDownload)(nil), "anytype.Rpc.UnsplashDownload")
	proto.RegisterType((*RpcUnsplashDownloadRequest)(nil), "anytype.Rpc.UnsplashDownload.Request")
	proto.RegisterType((*RpcUnsplashDownloadResponse)(nil), "anytype.Rpc.UnsplashDownload.Response")
	proto.RegisterType((*RpcUnsplashDownloadResponseError)(nil), "anytype.Rpc.UnsplashDownload.Response.Error")
	proto.RegisterType((*RpcApplyTemplate)(nil), "anytype.Rpc.ApplyTemplate")
	proto.RegisterType((*RpcApplyTemplateRequest)(nil), "anytype.Rpc.ApplyTemplate.Request")
	proto.RegisterType((*RpcApplyTemplateResponse)(nil), "anytype.Rpc.ApplyTemplate.Response")
	proto.RegisterType((*RpcApplyTemplateResponseError)(nil), "anytype.Rpc.ApplyTemplate.Response.Error")
	proto.RegisterType((*RpcDebug)(nil), "anytype.Rpc.Debug")
	proto.RegisterType((*RpcDebuglogInfo)(nil), "anytype.Rpc.Debug.logInfo")
	proto.RegisterType((*RpcDebugthreadInfo)(nil), "anytype.Rpc.Debug.threadInfo")
	proto.RegisterType((*RpcDebugSync)(nil), "anytype.Rpc.Debug.Sync")
	proto.RegisterType((*RpcDebugSyncRequest)(nil), "anytype.Rpc.Debug.Sync.Request")
	proto.RegisterType((*RpcDebugSyncResponse)(nil), "anytype.Rpc.Debug.Sync.Response")
	proto.RegisterType((*RpcDebugSyncResponseError)(nil), "anytype.Rpc.Debug.Sync.Response.Error")
	proto.RegisterType((*RpcDebugThread)(nil), "anytype.Rpc.Debug.Thread")
	proto.RegisterType((*RpcDebugThreadRequest)(nil), "anytype.Rpc.Debug.Thread.Request")
	proto.RegisterType((*RpcDebugThreadResponse)(nil), "anytype.Rpc.Debug.Thread.Response")
	proto.RegisterType((*RpcDebugThreadResponseError)(nil), "anytype.Rpc.Debug.Thread.Response.Error")
	proto.RegisterType((*RpcDebugTree)(nil), "anytype.Rpc.Debug.Tree")
	proto.RegisterType((*RpcDebugTreeRequest)(nil), "anytype.Rpc.Debug.Tree.Request")
	proto.RegisterType((*RpcDebugTreeResponse)(nil), "anytype.Rpc.Debug.Tree.Response")
	proto.RegisterType((*RpcDebugTreeResponseError)(nil), "anytype.Rpc.Debug.Tree.Response.Error")
	proto.RegisterType((*RpcGenericErrorResponse)(nil), "anytype.Rpc.GenericErrorResponse")
	proto.RegisterType((*RpcGenericErrorResponseError)(nil), "anytype.Rpc.GenericErrorResponse.Error")
	proto.RegisterType((*Empty)(nil), "anytype.Empty")
}

func init() { proto.RegisterFile("pb/protos/commands.proto", fileDescriptor_8261c968b2e6f45c) }

var fileDescriptor_8261c968b2e6f45c = []byte{
	// 10089 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x7b, 0x94, 0x24, 0x57,
	0x79, 0x9f, 0xba, 0xab, 0x1f, 0x33, 0xdf, 0xee, 0xec, 0xb6, 0xca, 0xcb, 0x6a, 0xb8, 0x12, 0x8b,
	0x58, 0x24, 0x21, 0x64, 0xd1, 0x8b, 0x56, 0x08, 0x24, 0xa1, 0x07, 0x3d, 0x3d, 0x3d, 0xbb, 0xad,
	0xed, 0xe9, 0x1e, 0x57, 0xf7, 0xec, 0xa2, 0xe0, 0x64, 0x52, 0xd3, 0x7d, 0x67, 0xa6, 0x98, 0x9a,
	0xaa, 0xa6, 0xaa, 0x7a, 0x56, 0xc3, 0x39, 0x4e, 0x0c, 0x18, 0xcb, 0xc0, 0x81, 0x18, 0xfc, 0xe0,
	0x15, 0xf3, 0x34, 0xc6, 0x60, 0x5e, 0xc2, 0x60, 0xf1, 0x08, 0x01, 0x3b, 0x22, 0x3c, 0x8c, 0x63,
	0x88, 0x1f, 0x18, 0x7c, 0x20, 0x20, 0xc2, 0x39, 0x49, 0x08, 0xc1, 0x38, 0xc4, 0x0e, 0xf6, 0xe1,
	0x38, 0xa7, 0x6e, 0xdd, 0x7a, 0xdc, 0x9e, 0xae, 0xea, 0x5b, 0x3d, 0x55, 0x3d, 0xcb, 0xc9, 0x5f,
	0xdd, 0xf7, 0xd6, 0xad, 0x7b, 0xbf, 0xfb, 0xfd, 0xbe, 0xfb, 0xa8, 0xef, 0x7e, 0xf7, 0xfb, 0x60,
	0xbe, 0xbf, 0x7e, 0xa6, 0x6f, 0xe8, 0x96, 0x6e, 0x9e, 0xe9, 0xea, 0x3b, 0x3b, 0xb2, 0xd6, 0x33,
	0xcb, 0x24, 0x2d, 0x16, 0x65, 0x6d, 0xcf, 0xda, 0xeb, 0x63, 0x74, 0x43, 0x7f, 0x7b, 0xf3, 0x8c,
	0xaa, 0xac, 0x9f, 0xe9, 0xaf, 0x9f, 0xd9, 0xd1, 0x7b, 0x58, 0x75, 0x5f, 0x20, 0x09, 0x5a, 0x1c,
	0xdd, 0x1c, 0x56, 0x4a, 0xd5, 0xbb, 0xb2, 0x6a, 0x5a, 0xba, 0x81, 0x69, 0xc9, 0x93, 0x7e, 0x93,
	0x78, 0x17, 0x6b, 0x96, 0x5b, 0xc3, 0x75, 0x9b, 0xba, 0xbe, 0xa9, 0x62, 0xe7, 0xd9, 0xfa, 0x60,
	0xe3, 0x8c, 0x69, 0x19, 0x83, 0xae, 0xe5, 0x3c, 0x3d, 0xfd, 0xc6, 0x37, 0xe7, 0x40, 0x90, 0xfa,
	0x5d, 0xf4, 0x58, 0x16, 0x8a, 0xcb, 0xd8, 0x32, 0x94, 0xae, 0x89, 0x3e, 0x96, 0x85, 0xb9, 0x36,
	0xb6, 0x56, 0x64, 0x43, 0xde, 0xc1, 0x16, 0x36, 0x4c, 0x74, 0x23, 0x14, 0x25, 0xfc, 0xa2, 0x01,
	0x36, 0x2d, 0x11, 0xc1, 0x4c, 0x5f, 0x95, 0xad, 0x0d, 0xdd, 0xd8, 0x99, 0xcf, 0x5c, 0x9f, 0xb9,
	0x79, 0x56, 0xf2, 0xd2, 0xe8, 0x9f, 0x32, 0x30, 0x23, 0x61, 0xb3, 0xaf, 0x6b, 0x26, 0x16, 0xcf,
	0x41, 0x1e, 0x1b, 0x86, 0x6e, 0x90, 0x52, 0x47, 0xce, 0xde, 0x56, 0xa6, 0x3d, 0x2f, 0x4b, 0xfd,
	0x6e, 0x99, 0x36, 0x55, 0x66, 0x9a, 0x29, 0xbb, 0xef, 0x96, 0x6b, 0xf6, 0x8b, 0x92, 0xf3, 0x3e,
	0x7a, 0x4f, 0x06, 0xf2, 0x24, 0x43, 0x7c, 0x00, 0x72, 0x5d, 0xbd, 0x87, 0x49, 0x8d, 0xc7, 0xce,
	0x3e, 0x3b, 0x76, 0x8d, 0xe5, 0xaa, 0xde, 0xc3, 0x12, 0xa9, 0x43, 0xbc, 0x1e, 0x8e, 0xf4, 0xb0,
	0xd9, 0x35, 0x94, 0xbe, 0xa5, 0xe8, 0xda, 0x7c, 0x96, 0x74, 0x25, 0x98, 0x75, 0xfa, 0x2c, 0xe4,
	0xec, 0xf2, 0xe2, 0x0c, 0xe4, 0x9a, 0xab, 0x8d, 0x46, 0xe9, 0x2a, 0xf1, 0x6a, 0x98, 0x5b, 0x6d,
	0x5e, 0x68, 0xb6, 0x2e, 0x35, 0xd7, 0x6a, 0x92, 0xd4, 0x92, 0x4a, 0x19, 0x71, 0x0e, 0x66, 0x17,
	0x2a, 0x8b, 0x6b, 0xf5, 0xe6, 0xca, 0x6a, 0xa7, 0x94, 0x45, 0xff, 0xa3, 0x00, 0x47, 0x6b, 0x0f,
	0x59, 0xd8, 0xd0, 0x64, 0x75, 0xd1, 0xd0, 0xfb, 0xe8, 0x71, 0x01, 0xf2, 0x4b, 0x8a, 0x8a, 0x4d,
	0xf4, 0x81, 0x8c, 0xcf, 0xc4, 0xeb, 0x60, 0xb6, 0xab, 0x6b, 0x16, 0x7e, 0xc8, 0xaa, 0xf7, 0x28,
	0x17, 0xfd, 0x0c, 0xf1, 0x34, 0x1c, 0xed, 0x19, 0x7a, 0xbf, 0x23, 0x1b, 0x9b, 0xd8, 0x2e, 0xe0,
	0xd0, 0xc6, 0xe4, 0x89, 0x77, 0xc1, 0x4c, 0x5f, 0x37, 0x15, 0x42, 0xbb, 0x40, 0xd8, 0xf1, 0x24,
	0x8f, 0x1d, 0x44, 0x50, 0xca, 0x0b, 0xaa, 0xde, 0xdd, 0x2e, 0xaf, 0xd0, 0x42, 0x92, 0x57, 0x5c,
	0xbc, 0x09, 0x8e, 0x11, 0xe9, 0xb1, 0xc9, 0x5a, 0x91, 0xad, 0x2d, 0x73, 0x3e, 0x77, 0xbd, 0x70,
	0xf3, 0xac, 0x34, 0x94, 0x8b, 0xde, 0x9d, 0x0d, 0xa0, 0xb9, 0xc8, 0xa2, 0x59, 0x66, 0x78, 0x1f,
	0xec, 0x71, 0x99, 0xf4, 0x76, 0x34, 0x94, 0xe2, 0xad, 0x90, 0x27, 0xc2, 0x49, 0xba, 0x74, 0xe4,
	0xec, 0x49, 0xbf, 0x16, 0x5a, 0xbc, 0x66, 0x3f, 0x95, 0x9c, 0x42, 0xe8, 0x77, 0x3c, 0xe0, 0xcf,
	0x31, 0xc0, 0xdf, 0x1e, 0xaf, 0xf1, 0xf4, 0x51, 0xff, 0x51, 0x16, 0x8a, 0x55, 0x1b, 0x3e, 0xcd,
	0x42, 0x0a, 0x2f, 0xca, 0x37, 0xc1, 0xb1, 0x0d, 0xbd, 0x3b, 0x30, 0x71, 0x8f, 0x20, 0xe5, 0xe1,
	0x3c, 0x94, 0x2b, 0xce, 0x43, 0xb1, 0xeb, 0xd4, 0x4d, 0x80, 0x3e, 0x2a, 0xb9, 0x49, 0xf4, 0x93,
	0xe0, 0x70, 0x5b, 0x62, 0x01, 0x7a, 0x66, 0x38, 0x8f, 0x28, 0xa5, 0x21, 0xa3, 0xed, 0x77, 0x3d,
	0xa6, 0xd7, 0x19, 0xa6, 0xdf, 0x11, 0xb7, 0xc2, 0xf4, 0xd9, 0xfe, 0x67, 0x67, 0x60, 0x96, 0x70,
	0xa9, 0xa1, 0x98, 0x16, 0xfa, 0xa0, 0x00, 0x27, 0xab, 0xba, 0xb6, 0x8b, 0x0d, 0xab, 0xba, 0xa5,
	0xa8, 0x3d, 0x03, 0x6b, 0x1d, 0x7d, 0x45, 0xde, 0xc4, 0x26, 0xea, 0xf2, 0x62, 0x82, 0x60, 0x66,
	0xdd, 0x61, 0xbb, 0x39, 0x9f, 0x25, 0x83, 0xc2, 0x4b, 0x8b, 0xa7, 0x00, 0xf4, 0xf5, 0x17, 0xe2,
	0xae, 0xd5, 0xd9, 0xeb, 0x63, 0x02, 0xc5, 0xac, 0x14, 0xc8, 0x41, 0x1f, 0x0c, 0x0e, 0x17, 0x89,
	0x45, 0xe3, 0x1e, 0x86, 0x79, 0x1e, 0xcd, 0xe5, 0xd1, 0xf4, 0x86, 0x0c, 0x9e, 0x79, 0x28, 0xaa,
	0x8a, 0x16, 0xa0, 0xcd, 0x4d, 0xa2, 0x8f, 0x78, 0x98, 0xad, 0x32, 0x98, 0x55, 0x0e, 0xd2, 0x6c,
	0xfa, 0xf8, 0xfd, 0xbd, 0x00, 0xb9, 0x65, 0x7d, 0x17, 0xa3, 0x2f, 0x65, 0x92, 0x00, 0xe8, 0x66,
	0x38, 0x6e, 0x91, 0xe9, 0xb1, 0xea, 0xbd, 0xef, 0xa0, 0x34, 0x9c, 0xbd, 0x6f, 0x82, 0xcd, 0x8d,
	0x99, 0x60, 0xf3, 0xb1, 0x26, 0x58, 0xf4, 0xd6, 0xa0, 0x24, 0x3c, 0x8f, 0x95, 0x84, 0x5b, 0x42,
	0x20, 0xb1, 0xf9, 0x90, 0xc8, 0xa4, 0xf9, 0x0e, 0x4f, 0x16, 0xaa, 0x8c, 0x2c, 0x9c, 0xe1, 0x6f,
	0x38, 0x7d, 0xe4, 0x7f, 0x3f, 0x07, 0x73, 0x76, 0xc3, 0x1d, 0xbd, 0x89, 0x2f, 0xdb, 0xc2, 0x87,
	0xfe, 0x22, 0x11, 0x11, 0xb8, 0x0d, 0x8a, 0x3d, 0x6c, 0xc9, 0x8a, 0x6a, 0x12, 0xe8, 0x8f, 0x9c,
	0xbd, 0xa6, 0xec, 0x6c, 0x7f, 0xca, 0xee, 0xf6, 0xa7, 0xdc, 0x26, 0xdb, 0x1f, 0xc9, 0x2d, 0x97,
	0xb6, 0x2c, 0x7c, 0x21, 0x28, 0x0b, 0x75, 0x56, 0x16, 0x6e, 0x8f, 0x80, 0xc4, 0xe3, 0x4c, 0x88,
	0x50, 0x9c, 0x84, 0x82, 0x33, 0xfa, 0x29, 0x24, 0x34, 0xe5, 0x0b, 0x8b, 0xc0, 0x23, 0x2c, 0xbf,
	0xe7, 0x09, 0x4b, 0x83, 0x11, 0x96, 0x3b, 0x27, 0xa0, 0x2c, 0x7d, 0xa9, 0xf9, 0x1b, 0x01, 0x66,
	0x17, 0x07, 0x7d, 0x55, 0xe9, 0xca, 0x16, 0x46, 0x6f, 0x8a, 0x23, 0x31, 0x16, 0xbb, 0x97, 0xf2,
	0xd2, 0x8c, 0x34, 0x09, 0x43, 0xd2, 0x14, 0x84, 0x3d, 0x17, 0x0f, 0xf6, 0xcf, 0x06, 0x61, 0xaf,
	0xb1, 0xb0, 0x87, 0x8d, 0x44, 0xaf, 0x6b, 0x21, 0x90, 0x47, 0x09, 0x7e, 0x3c, 0xd8, 0xdf, 0xed,
	0xc1, 0x7e, 0x9e, 0x81, 0xfd, 0x59, 0x31, 0x29, 0x4b, 0x1f, 0xf2, 0x8f, 0x5c, 0x07, 0x42, 0x1b,
	0x5b, 0xe8, 0xb7, 0x01, 0x72, 0x1d, 0xfc, 0x90, 0x85, 0xfe, 0x48, 0x80, 0x7c, 0xdb, 0xda, 0x53,
	0x31, 0x7a, 0x69, 0x22, 0x33, 0xc6, 0xbd, 0x90, 0x37, 0xed, 0xea, 0xe8, 0x26, 0xfa, 0x69, 0x23,
	0x01, 0x76, 0x37, 0x38, 0x36, 0x05, 0x65, 0xd2, 0xba, 0xe4, 0xbc, 0x85, 0x7e, 0x3f, 0x88, 0xf3,
	0x03, 0x2c, 0xce, 0x61, 0xdc, 0x6c, 0xe3, 0x60, 0x4d, 0x89, 0x4c, 0xfa, 0xef, 0xf3, 0x00, 0x5d,
	0x66, 0x00, 0xbd, 0x6b, 0x12, 0x12, 0xd2, 0x47, 0xf5, 0x0d, 0x02, 0xe4, 0xab, 0xba, 0xaa, 0x1b,
	0xe8, 0xc1, 0x24, 0x30, 0x3c, 0x01, 0xf9, 0xae, 0x5d, 0x1b, 0x5d, 0xee, 0x9d, 0xc4, 0xc1, 0xa0,
	0x21, 0xd4, 0x1d, 0x2e, 0x34, 0xa3, 0x48, 0x48, 0x1f, 0x9a, 0x4f, 0xda, 0x7b, 0x32, 0xd9, 0xd8,
	0x46, 0xff, 0x3a, 0x09, 0x64, 0xee, 0x86, 0xdc, 0x8e, 0x6c, 0x6c, 0xd3, 0x59, 0xe9, 0xa6, 0xf1,
	0x83, 0xcb, 0x6e, 0x5a, 0x22, 0xef, 0xa0, 0x47, 0x26, 0x58, 0x39, 0x3d, 0xe6, 0xd9, 0xf5, 0x24,
	0x02, 0x5f, 0xdc, 0x15, 0x32, 0x8a, 0x82, 0xf4, 0xd1, 0x7b, 0x9f, 0x00, 0xc7, 0x17, 0xe4, 0xee,
	0xf6, 0xa6, 0xa1, 0x0f, 0xb4, 0x5e, 0xea, 0x43, 0xec, 0x53, 0x41, 0x88, 0x5a, 0x2c, 0x44, 0x51,
	0xf2, 0x3d, 0x44, 0x62, 0x22, 0x40, 0x3d, 0xe2, 0x01, 0x25, 0x31, 0x40, 0xdd, 0x37, 0x31, 0x1d,
	0xe9, 0xc3, 0xf5, 0x5e, 0x01, 0xf2, 0x15, 0x55, 0xd9, 0xd4, 0xd0, 0x20, 0x09, 0x90, 0x9e, 0x09,
	0x79, 0xd9, 0xae, 0x8d, 0xae, 0x65, 0x68, 0xe4, 0x70, 0x23, 0xed, 0x49, 0x4e, 0x41, 0xf4, 0x9e,
	0x09, 0xb6, 0x29, 0x36, 0xe3, 0x48, 0x25, 0x89, 0xc0, 0x16, 0x77, 0x2b, 0x12, 0xd6, 0x7a, 0xfa,
	0x60, 0xbd, 0x36, 0x07, 0x85, 0x25, 0x05, 0xab, 0x3d, 0x13, 0xfd, 0x15, 0xf7, 0xd6, 0xe3, 0x22,
	0x1c, 0x21, 0xf0, 0x38, 0x2f, 0x12, 0xc4, 0xa2, 0x57, 0x1f, 0xa7, 0x60, 0x99, 0xd6, 0xee, 0x3c,
	0x24, 0x79, 0x52, 0xb0, 0x22, 0x74, 0x09, 0xc0, 0x7f, 0x24, 0xce, 0x43, 0x91, 0x0a, 0x01, 0xa5,
	0xc0, 0x4d, 0x8a, 0x67, 0xa0, 0xb0, 0xe1, 0x36, 0x1d, 0xf9, 0x3d, 0x44, 0x8b, 0xa1, 0xdf, 0xcb,
	0xf2, 0xea, 0x94, 0x42, 0xe8, 0x3e, 0xb8, 0x48, 0xf0, 0x69, 0xa0, 0x38, 0x9a, 0x4f, 0x5f, 0x26,
	0x3e, 0x27, 0x80, 0xb0, 0xa8, 0xec, 0xa2, 0x4f, 0x7b, 0xbb, 0xd2, 0x97, 0x24, 0xb2, 0x2b, 0xbd,
	0x87, 0xdd, 0x95, 0x46, 0x2f, 0x9c, 0x8b, 0xca, 0x2e, 0xbb, 0x29, 0x9d, 0x74, 0xe5, 0xf4, 0x2a,
	0x3a, 0xb4, 0x95, 0x33, 0x8c, 0x82, 0xf4, 0x91, 0xfc, 0x63, 0x01, 0x72, 0x4b, 0x8a, 0x8a, 0x0f,
	0xf7, 0x03, 0xc3, 0xa6, 0x20, 0x99, 0x0f, 0x0c, 0xbf, 0xa6, 0x43, 0xdb, 0xc5, 0x86, 0x92, 0x90,
	0x3e, 0x9a, 0x1f, 0x17, 0x60, 0xa6, 0x33, 0x30, 0xb4, 0xba, 0x66, 0xe9, 0x57, 0xc6, 0x87, 0x22,
	0xff, 0x61, 0x8a, 0xcf, 0x44, 0xb7, 0x07, 0x53, 0x3c, 0x4c, 0x19, 0xdb, 0x78, 0xfa, 0xd8, 0xbd,
	0xfc, 0x1b, 0x19, 0xc8, 0x13, 0x3a, 0xd0, 0x87, 0x05, 0x1b, 0xb9, 0xbe, 0x2a, 0x77, 0x31, 0xda,
	0xe1, 0x05, 0x31, 0xb0, 0x18, 0x66, 0xd9, 0xc5, 0xf0, 0x16, 0xc8, 0x93, 0xbf, 0xf4, 0x73, 0xe4,
	0xc4, 0x28, 0x08, 0x25, 0xa7, 0x08, 0x7a, 0x34, 0x88, 0xd7, 0xfd, 0x2c, 0x5e, 0x4f, 0xdf, 0xcf,
	0xb2, 0x32, 0x25, 0x33, 0x5c, 0x75, 0x1f, 0x42, 0x53, 0x3c, 0xc5, 0xcd, 0xdb, 0x3d, 0x10, 0x17,
	0x18, 0x10, 0xcb, 0xdc, 0x14, 0x4d, 0x65, 0x53, 0x3b, 0xb7, 0xda, 0xef, 0xc9, 0x16, 0x76, 0x8f,
	0xc4, 0xa6, 0x0c, 0x5d, 0xcc, 0x4d, 0x6d, 0x99, 0x21, 0x76, 0xdc, 0x58, 0x4b, 0x5a, 0xbf, 0x16,
	0xd9, 0x7a, 0xfa, 0x60, 0x7d, 0x3d, 0x07, 0xf9, 0x76, 0x5f, 0x55, 0x2c, 0xf4, 0xa6, 0x6c, 0x22,
	0x28, 0x19, 0xb2, 0xb6, 0x89, 0x43, 0x50, 0x92, 0xec, 0x67, 0x92, 0x53, 0xc4, 0x9f, 0x4f, 0x73,
	0x93, 0xcc, 0xa7, 0xe2, 0x5d, 0x90, 0xb3, 0x0b, 0x52, 0x75, 0xfc, 0x8d, 0x23, 0x18, 0x4b, 0xba,
	0xe5, 0x6d, 0xa4, 0x97, 0x09, 0x27, 0xed, 0x57, 0x4e, 0xdf, 0x06, 0x39, 0x3b, 0x25, 0x02, 0x14,
	0x16, 0x5a, 0x9d, 0x4e, 0x6b, 0xb9, 0x74, 0x95, 0x58, 0x04, 0xa1, 0xd3, 0x5a, 0x29, 0x65, 0xc4,
	0x59, 0xc8, 0xd7, 0x9b, 0xcd, 0x9a, 0x54, 0xca, 0xda, 0x7f, 0x3b, 0xf5, 0x4e, 0xa3, 0x56, 0x12,
	0xd8, 0x55, 0xf8, 0x5e, 0x56, 0xa4, 0x9e, 0x16, 0xd1, 0x76, 0x9a, 0x73, 0xc1, 0x5b, 0x3d, 0x21,
	0x7b, 0x1e, 0x23, 0x64, 0xb7, 0x72, 0xd2, 0x93, 0xbe, 0x70, 0xfd, 0xa6, 0x00, 0xf9, 0x65, 0x6c,
	0x6c, 0x62, 0xf4, 0xa2, 0x18, 0xa6, 0x0f, 0x1b, 0x8a, 0x61, 0x5a, 0xec, 0x91, 0x38, 0x93, 0x27,
	0xde, 0x00, 0x73, 0x26, 0xee, 0xea, 0x9a, 0x77, 0x6e, 0xee, 0xe8, 0x24, 0xd8, 0x4c, 0xf4, 0xc6,
	0x98, 0x90, 0x11, 0x42, 0x13, 0x59, 0x69, 0xe3, 0x00, 0x33, 0xaa, 0xd5, 0xf4, 0x81, 0xf9, 0x3b,
	0xc1, 0x7e, 0xa9, 0xbf, 0x87, 0xde, 0xc8, 0xbd, 0x35, 0xba, 0x15, 0x0a, 0x44, 0x4c, 0xdd, 0x6f,
	0xd8, 0xd1, 0x33, 0x30, 0x2d, 0x23, 0x2e, 0xc0, 0xd5, 0x26, 0x56, 0x71, 0xd7, 0xc2, 0x3d, 0x7b,
	0xe8, 0x4a, 0x63, 0x27, 0x85, 0xfd, 0xc5, 0xd1, 0x57, 0x82, 0x00, 0xde, 0xc3, 0x02, 0x78, 0xd3,
	0x08, 0x56, 0xda, 0x1d, 0x0a, 0x3f, 0x39, 0xb1, 0xbb, 0xd1, 0x56, 0x75, 0xcb, 0x3b, 0x00, 0xa2,
	0x69, 0xfb, 0xd9, 0x96, 0xb5, 0xa3, 0x92, 0x67, 0x8e, 0x20, 0x79, 0x69, 0xb1, 0x0c, 0x45, 0x59,
	0xdb, 0x23, 0x8f, 0x72, 0x11, 0xbd, 0x76, 0x0b, 0xa1, 0xb7, 0x78, 0xc8, 0xdf, 0xcf, 0x20, 0xff,
	0xb3, 0x7c, 0xe4, 0xa6, 0x0f, 0xfc, 0xdf, 0x16, 0x20, 0xbf, 0x22, 0x9b, 0x16, 0x46, 0xdf, 0x14,
	0x92, 0xb6, 0x53, 0x49, 0x00, 0x73, 0xf1, 0x16, 0x28, 0xb9, 0x99, 0x0b, 0xee, 0x46, 0xdc, 0x31,
	0x4e, 0xda, 0x97, 0x6f, 0x4f, 0x03, 0x8a, 0xb9, 0x22, 0x1b, 0x56, 0x6b, 0x83, 0xe4, 0x91, 0xa5,
	0x60, 0x46, 0x62, 0x33, 0x19, 0xe8, 0x0b, 0x11, 0xd0, 0x17, 0xc3, 0xa1, 0x9f, 0xe1, 0x80, 0x5e,
	0xac, 0xc0, 0xcc, 0x86, 0xa2, 0x62, 0xf2, 0xc2, 0x2c, 0x79, 0x61, 0xd4, 0x9a, 0x44, 0x78, 0xef,
	0xad, 0x49, 0xf6, 0x07, 0x92, 0xe4, 0xbd, 0x86, 0x1a, 0xce, 0x17, 0xa8, 0x28, 0x42, 0x4e, 0x93,
	0x77, 0x30, 0x45, 0x82, 0xfc, 0xb7, 0xf3, 0x7a, 0xb2, 0x25, 0x13, 0xd6, 0x1f, 0x95, 0xc8, 0x7f,
	0x1b, 0x36, 0x62, 0xb1, 0xb5, 0x22, 0x5b, 0x5b, 0x54, 0x74, 0xfd, 0x0c, 0xf4, 0xb0, 0x10, 0x6f,
	0xfe, 0x73, 0x49, 0x8b, 0x7b, 0xf2, 0x78, 0x03, 0xcc, 0x75, 0x65, 0x03, 0x5b, 0x2b, 0x41, 0x6b,
	0xb4, 0xbc, 0xc4, 0x66, 0xda, 0xc0, 0x2a, 0x66, 0x5b, 0xde, 0xc1, 0xa4, 0xb1, 0xaa, 0xfd, 0x8c,
	0x2c, 0xfc, 0x33, 0xd2, 0xbe, 0x7c, 0x7f, 0xb6, 0xcd, 0x27, 0x3d, 0xdb, 0x8e, 0xea, 0x63, 0xfa,
	0x83, 0xee, 0xed, 0x39, 0x10, 0xaa, 0x03, 0xeb, 0x8a, 0x9e, 0x6c, 0x7f, 0x12, 0x9c, 0x6c, 0x9f,
	0xcb, 0x4a, 0xcb, 0x28, 0x41, 0xae, 0x0e, 0xac, 0xc3, 0x9d, 0x6b, 0x63, 0x4a, 0xc9, 0x6f, 0x79,
	0x52, 0x72, 0x1f, 0x23, 0x25, 0xb7, 0x70, 0xf5, 0x2d, 0x7d, 0x19, 0x79, 0x8f, 0x00, 0xc7, 0xea,
	0x3b, 0x7d, 0xdd, 0xb0, 0x96, 0x65, 0x63, 0xbb, 0xa7, 0x5f, 0xd6, 0xd0, 0x39, 0x5e, 0x69, 0x39,
	0x05, 0xa0, 0x90, 0x57, 0xc9, 0x44, 0xe0, 0x10, 0x14, 0xc8, 0x41, 0x7f, 0x12, 0x4f, 0xa5, 0x5b,
	0x66, 0xe9, 0x08, 0x81, 0xf9, 0x7a, 0x38, 0x62, 0xe8, 0xba, 0xd5, 0x60, 0x0c, 0xd2, 0x82, 0x59,
	0x31, 0x77, 0xb3, 0x31, 0x94, 0xbe, 0xd1, 0x04, 0x4e, 0xe1, 0x20, 0x40, 0x80, 0x42, 0xed, 0x21,
	0x9b, 0x04, 0xb4, 0x9a, 0xca, 0x88, 0x66, 0x4d, 0x09, 0xef, 0x63, 0x11, 0xbb, 0x79, 0x04, 0x43,
	0x1c, 0x6a, 0x42, 0x90, 0x12, 0x21, 0xd7, 0xf7, 0x05, 0x83, 0xfc, 0x8f, 0x89, 0xcd, 0xdb, 0x3c,
	0x6c, 0x2a, 0x0c, 0x36, 0xcf, 0xe0, 0x25, 0x25, 0x7d, 0x4c, 0x5e, 0x2f, 0x40, 0x61, 0xb5, 0xaf,
	0xea, 0x72, 0x0f, 0xe9, 0x07, 0xff, 0x8e, 0x45, 0xce, 0x62, 0x1e, 0x58, 0x58, 0xbd, 0xb4, 0x58,
	0x02, 0x61, 0x60, 0xa8, 0xd4, 0x4c, 0xcc, 0xfe, 0x8b, 0xde, 0x1c, 0x13, 0x2d, 0x87, 0xce, 0x44,
	0x3e, 0x35, 0xe2, 0x20, 0x33, 0xb2, 0xd9, 0xf4, 0x91, 0xf9, 0x41, 0x16, 0x66, 0x16, 0xf5, 0xcb,
	0x1a, 0xc1, 0xa6, 0x72, 0x60, 0x6c, 0xe2, 0x1a, 0x57, 0x96, 0xdd, 0xb6, 0xa7, 0x6d, 0x5c, 0x19,
	0xd6, 0x70, 0xfa, 0x1c, 0x7f, 0xfc, 0x76, 0xc7, 0x66, 0xea, 0x1d, 0x82, 0x77, 0x60, 0x69, 0x1c,
	0x7c, 0x4c, 0xf8, 0x27, 0x89, 0x02, 0xdf, 0x49, 0xe2, 0x3b, 0x83, 0x40, 0x2d, 0xb0, 0x40, 0x8d,
	0xd4, 0x51, 0x24, 0x7b, 0x8a, 0xf8, 0xdb, 0x1e, 0x54, 0x35, 0x06, 0xaa, 0xdb, 0xe2, 0x34, 0x9d,
	0x3e, 0x58, 0xdf, 0x15, 0xa0, 0xb8, 0xe8, 0x98, 0xa2, 0xa2, 0xf3, 0x50, 0x70, 0xfe, 0xda, 0x93,
	0xcc, 0x36, 0xde, 0xa3, 0xf0, 0xd8, 0x7f, 0xed, 0xce, 0xef, 0xca, 0xea, 0x00, 0x7b, 0x9d, 0x1f,
	0xe6, 0xfe, 0x45, 0xfb, 0xa9, 0xe4, 0x14, 0x42, 0x5b, 0xbc, 0x78, 0xdf, 0xef, 0x1b, 0xcc, 0x66,
	0x43, 0xbf, 0x5a, 0xc8, 0xc9, 0x9c, 0x53, 0x8a, 0xfe, 0x7a, 0xe6, 0xb3, 0xe8, 0x5d, 0x41, 0x94,
	0xab, 0x2c, 0xca, 0xcf, 0x18, 0x53, 0x57, 0x12, 0x30, 0xbf, 0xcb, 0x83, 0x79, 0x89, 0x81, 0xf9,
	0x6c, 0xac, 0xb6, 0xa7, 0x72, 0xbe, 0x78, 0x54, 0xc2, 0xa6, 0x65, 0x28, 0x5d, 0xbb, 0x0e, 0x13,
	0xfd, 0x4a, 0xe6, 0xe0, 0x63, 0xb2, 0x06, 0x47, 0x8d, 0x40, 0x9d, 0x74, 0x64, 0x3e, 0x65, 0xa4,
	0x2a, 0x35, 0xd8, 0xb8, 0xc4, 0xbc, 0xc6, 0x6e, 0x37, 0xce, 0xb3, 0x18, 0x86, 0xf1, 0x31, 0x58,
	0x5d, 0x22, 0x40, 0xbe, 0xd7, 0x03, 0xf2, 0x02, 0x03, 0xe4, 0x73, 0xe2, 0x13, 0x90, 0x3e, 0x9a,
	0x2f, 0x15, 0x20, 0x47, 0xcc, 0xd6, 0x7f, 0x9c, 0x05, 0xa8, 0x9b, 0x15, 0xa3, 0xbb, 0xa5, 0xec,
	0xe2, 0x1e, 0x92, 0x0f, 0x8e, 0xa9, 0xbd, 0x9b, 0xf7, 0x2a, 0x24, 0x88, 0xce, 0x48, 0x81, 0x1c,
	0xf4, 0x70, 0x10, 0xac, 0x0b, 0x2c, 0x58, 0x77, 0x84, 0xf0, 0x8a, 0x58, 0x6b, 0xfb, 0x64, 0x86,
	0xdc, 0xfc, 0x79, 0xbf, 0x87, 0x40, 0x93, 0x41, 0xe0, 0xee, 0x89, 0x6a, 0x4d, 0x1f, 0x84, 0xdf,
	0x10, 0x20, 0xdf, 0x90, 0x2d, 0xfc, 0x10, 0x7a, 0x95, 0x40, 0xad, 0x83, 0x57, 0x0f, 0xce, 0x7f,
	0x11, 0x72, 0x76, 0x19, 0xba, 0xef, 0x23, 0xff, 0xe3, 0x1a, 0xc5, 0x10, 0xee, 0x10, 0xca, 0x9c,
	0x83, 0x8b, 0x29, 0x1b, 0xc5, 0x44, 0x37, 0x9f, 0x3e, 0x2e, 0xdf, 0x2f, 0x51, 0x34, 0xbe, 0xe0,
	0xc2, 0xf2, 0xeb, 0x99, 0x54, 0x70, 0x11, 0xef, 0x85, 0xfc, 0x8e, 0x6c, 0x6c, 0x9b, 0x64, 0x37,
	0x7e, 0x84, 0xe7, 0x0c, 0xc9, 0xfe, 0x68, 0x34, 0x25, 0xe7, 0xad, 0xd8, 0x07, 0x85, 0x9e, 0x6d,
	0x67, 0x62, 0xa8, 0xc6, 0x39, 0x28, 0x8c, 0x6a, 0x3d, 0x7d, 0x50, 0x5f, 0xe3, 0x99, 0x6c, 0x5f,
	0x3a, 0x38, 0x96, 0xa3, 0xad, 0x49, 0x27, 0x19, 0x65, 0x09, 0x1b, 0x6b, 0xc7, 0x1d, 0x65, 0x87,
	0x68, 0xa8, 0xfd, 0x31, 0xcf, 0x4e, 0xe9, 0x17, 0x13, 0x18, 0x5d, 0x07, 0xb4, 0x6e, 0x99, 0x18,
	0xba, 0xe4, 0x2c, 0x94, 0x26, 0x82, 0xee, 0xd0, 0xae, 0x3f, 0x14, 0xab, 0x5b, 0xb8, 0xbb, 0x8d,
	0x7b, 0xe8, 0x05, 0x07, 0xc7, 0x6e, 0x1e, 0x8a, 0x5d, 0xa7, 0x36, 0xba, 0x5d, 0x70, 0x93, 0x13,
	0x6d, 0xec, 0x1c, 0x91, 0x76, 0x2a, 0x38, 0x94, 0x8d, 0x5d, 0x04, 0x01, 0xe9, 0x43, 0xf3, 0x88,
	0x00, 0xb9, 0x7a, 0x57, 0xd7, 0xd0, 0x2f, 0x1c, 0x1c, 0x97, 0xeb, 0x60, 0x56, 0xe9, 0xea, 0x5a,
	0x7d, 0x47, 0xde, 0x74, 0xef, 0x0b, 0xfb, 0x19, 0xee, 0xd3, 0xda, 0x8e, 0xfe, 0x42, 0x85, 0xe8,
	0xb0, 0xe9, 0x53, 0x92, 0x31, 0xf9, 0xd2, 0x64, 0x13, 0x7f, 0x78, 0x4b, 0xd3, 0x88, 0xd6, 0xd3,
	0xc7, 0xec, 0x75, 0xae, 0xe9, 0xe6, 0x2b, 0x04, 0xc8, 0x35, 0xe5, 0x1d, 0x9c, 0xd0, 0x36, 0x90,
	0x1c, 0xc2, 0x09, 0xfe, 0x21, 0xdc, 0x44, 0xa0, 0x10, 0x23, 0x48, 0x9b, 0xa8, 0x43, 0x01, 0x25,
	0xac, 0xf5, 0xf4, 0x41, 0xf9, 0x52, 0x1e, 0xf2, 0x44, 0xd0, 0xd1, 0x37, 0xb2, 0xe9, 0xa2, 0xc2,
	0xef, 0x05, 0xc1, 0xe7, 0x0b, 0xa1, 0x2c, 0x02, 0x96, 0xd8, 0xab, 0x49, 0x68, 0x85, 0x53, 0x50,
	0xf7, 0x65, 0x21, 0x7f, 0x49, 0xe9, 0x59, 0x5b, 0x09, 0xed, 0xcc, 0x2e, 0xdb, 0x75, 0xd1, 0x53,
	0x5c, 0x27, 0x11, 0xc3, 0xaf, 0xcb, 0x30, 0x47, 0x08, 0x61, 0x07, 0xf2, 0xeb, 0xc2, 0x53, 0xe3,
	0x74, 0xc4, 0xf9, 0xa2, 0xd2, 0xc3, 0xfa, 0x15, 0x29, 0xce, 0x84, 0xb2, 0x24, 0xc5, 0x39, 0xb4,
	0xc2, 0xff, 0x6f, 0xc5, 0xd9, 0xe1, 0x48, 0x92, 0xe2, 0x1c, 0x5e, 0x63, 0xfa, 0x4c, 0xfe, 0xb4,
	0x00, 0xb9, 0x86, 0xa2, 0x6d, 0xa3, 0x3f, 0x10, 0x60, 0xce, 0x71, 0x73, 0xe0, 0xda, 0xcd, 0x6d,
	0x1e, 0x9c, 0xeb, 0x37, 0xc0, 0x9c, 0x15, 0xac, 0xd3, 0x35, 0xd0, 0x63, 0x32, 0xd1, 0x27, 0x83,
	0xab, 0x69, 0x93, 0x45, 0xe1, 0xce, 0x30, 0xad, 0x86, 0xa2, 0x6d, 0x97, 0x19, 0x7a, 0x13, 0x59,
	0x56, 0x3f, 0xe4, 0x41, 0xf7, 0x73, 0x0c, 0x74, 0xf7, 0x4e, 0x4a, 0x46, 0xfa, 0x08, 0x3e, 0x56,
	0xb0, 0xb9, 0xa7, 0xca, 0xc4, 0xdb, 0xc0, 0xab, 0x05, 0x28, 0xb4, 0xb1, 0x75, 0x01, 0xef, 0xa1,
	0xf6, 0xc1, 0xe1, 0xa3, 0x87, 0x0f, 0x82, 0x77, 0xf8, 0x80, 0xde, 0x9f, 0x8d, 0x37, 0x60, 0x5c,
	0xc2, 0xca, 0x0e, 0x51, 0x89, 0x60, 0x14, 0x67, 0x78, 0x45, 0xb7, 0x9f, 0x3e, 0x38, 0xef, 0x16,
	0x40, 0xa8, 0xf4, 0x7a, 0x68, 0xf7, 0xe0, 0x60, 0xdc, 0x0e, 0x33, 0x06, 0xed, 0x8d, 0x77, 0xf0,
	0x36, 0x64, 0xd3, 0x43, 0x1f, 0x4b, 0x5e, 0xc1, 0xb8, 0x97, 0x4d, 0x7c, 0x7e, 0x55, 0x7a, 0xbd,
	0x69, 0x5f, 0x36, 0x89, 0x6a, 0x3c, 0x7d, 0xa4, 0x3e, 0x20, 0x00, 0xb4, 0x7c, 0x1f, 0x4e, 0x6f,
	0x15, 0x9c, 0xa3, 0xd3, 0x65, 0x5e, 0xe0, 0x6e, 0x80, 0x39, 0xdf, 0x05, 0xd4, 0xaa, 0xa1, 0xba,
	0x53, 0x1d, 0x93, 0x89, 0x3e, 0x1f, 0x53, 0x3d, 0xe2, 0x53, 0xe4, 0x1e, 0x75, 0x1c, 0x18, 0x91,
	0xcf, 0xc6, 0xd8, 0x01, 0x44, 0x36, 0x1f, 0x0f, 0x93, 0x56, 0x7c, 0x4c, 0xc4, 0x6b, 0xe1, 0x1a,
	0xb7, 0x44, 0x6b, 0xe1, 0x81, 0x5a, 0xb5, 0xb3, 0xd6, 0x79, 0x70, 0xa5, 0xb6, 0xb6, 0x2a, 0x35,
	0x4a, 0x02, 0x7a, 0x7d, 0x11, 0x66, 0x16, 0x74, 0x7d, 0x9b, 0xb8, 0x08, 0x78, 0xa5, 0x00, 0xf9,
	0x25, 0x6c, 0x75, 0xb7, 0x12, 0x9a, 0xf6, 0x06, 0x1e, 0x80, 0xc4, 0xb0, 0x23, 0xae, 0x56, 0xcb,
	0xa5, 0xab, 0x4c, 0x68, 0x9a, 0xba, 0x56, 0x2b, 0xb2, 0xf9, 0xf4, 0x87, 0xd2, 0x4f, 0x04, 0x38,
	0x56, 0x35, 0xb0, 0x6c, 0xe1, 0x8a, 0xd6, 0x73, 0x50, 0xf9, 0xd5, 0x44, 0x5c, 0xf4, 0x1c, 0xc0,
	0xd5, 0xe1, 0x7e, 0x63, 0x9d, 0xaf, 0xc6, 0x73, 0x59, 0xe0, 0x33, 0x95, 0xed, 0x5a, 0xca, 0x77,
	0x3b, 0x62, 0x38, 0x33, 0xe0, 0xa4, 0x30, 0x7d, 0xfc, 0xbf, 0x93, 0xa3, 0x6a, 0x98, 0xaf, 0xe7,
	0xe0, 0xb8, 0x47, 0x0b, 0x35, 0xca, 0xfa, 0xdb, 0x2b, 0x4e, 0x12, 0x58, 0xf3, 0xe9, 0xfc, 0x90,
	0xf9, 0xb4, 0xb8, 0xe0, 0x98, 0x80, 0x11, 0x5f, 0x7f, 0x05, 0x8e, 0x4b, 0xd8, 0x44, 0xd3, 0x62,
	0x97, 0x96, 0xbc, 0xf7, 0xd8, 0x1b, 0x0c, 0x0d, 0x56, 0xd6, 0x46, 0x6d, 0x5b, 0x48, 0x1d, 0x43,
	0x9c, 0x4b, 0x59, 0xd0, 0x3e, 0xe0, 0x09, 0x5a, 0x8b, 0x11, 0xb4, 0xe7, 0x4e, 0x46, 0xde, 0x14,
	0x3c, 0x9c, 0xdc, 0x03, 0x33, 0x8b, 0xb2, 0x25, 0xef, 0x2a, 0xf8, 0x32, 0xfa, 0x96, 0x00, 0x70,
	0x51, 0xc1, 0x97, 0x1d, 0xa2, 0x62, 0xdc, 0xbd, 0x0f, 0x67, 0xdf, 0x7d, 0x90, 0xb3, 0xab, 0xa6,
	0x27, 0x8a, 0xb7, 0x44, 0x5f, 0xbc, 0xa7, 0x74, 0x94, 0x6d, 0x1a, 0x24, 0xf2, 0x1e, 0x6b, 0x6c,
	0xcb, 0x71, 0x3c, 0xcf, 0xd4, 0xe1, 0xf4, 0x23, 0x89, 0x85, 0x43, 0x3c, 0x09, 0x05, 0xbb, 0x5a,
	0xef, 0xe3, 0x8b, 0xa6, 0x62, 0x1d, 0xf2, 0x8f, 0xa7, 0x2d, 0x7d, 0xbc, 0x5d, 0x88, 0x9d, 0x6b,
	0x92, 0x31, 0x6c, 0xe8, 0xc3, 0x21, 0x0e, 0x61, 0xcd, 0x81, 0xa1, 0xff, 0xe8, 0x41, 0xa0, 0x77,
	0xfa, 0x97, 0xc8, 0x9e, 0x61, 0x62, 0x88, 0x47, 0xd2, 0x90, 0x3e, 0xc4, 0x6f, 0xa5, 0x10, 0x2f,
	0x62, 0x15, 0x5b, 0x98, 0xdf, 0x5f, 0x11, 0x0f, 0xc2, 0x39, 0x46, 0xf8, 0x0f, 0x84, 0x90, 0x43,
	0xde, 0xe1, 0x22, 0x34, 0x92, 0x86, 0xf4, 0x11, 0xfa, 0xa2, 0x00, 0xc7, 0xed, 0xe6, 0xdb, 0xfe,
	0x8d, 0x1e, 0x7e, 0x8f, 0x45, 0xb1, 0x61, 0x22, 0x2e, 0xc6, 0x83, 0xee, 0x36, 0xe7, 0x02, 0x8e,
	0x15, 0x3f, 0x1d, 0x84, 0x70, 0x85, 0x85, 0x70, 0x2c, 0xfb, 0x02, 0xf4, 0x27, 0x82, 0xe3, 0x87,
	0x3d, 0x1c, 0xdb, 0x0c, 0x8e, 0xf7, 0x4f, 0x4e, 0x48, 0xfa, 0x60, 0x7e, 0x55, 0x80, 0x39, 0x4a,
	0x43, 0xa5, 0x6b, 0x29, 0xbb, 0x18, 0x3d, 0x9c, 0xe2, 0xa4, 0x7a, 0x12, 0x0a, 0xfa, 0xc6, 0x86,
	0x49, 0xaf, 0x7b, 0xcd, 0x49, 0x34, 0x25, 0x9e, 0x80, 0xbc, 0xaa, 0xec, 0x28, 0x16, 0x05, 0xd8,
	0x49, 0xc4, 0xd6, 0x09, 0x0e, 0x33, 0xd5, 0xe9, 0xd0, 0xd4, 0x75, 0x82, 0x5c, 0x64, 0xa4, 0x8f,
	0xec, 0xfb, 0x89, 0x8d, 0x69, 0x57, 0x37, 0x7a, 0x74, 0xb5, 0x7c, 0x4d, 0x26, 0x91, 0xbb, 0x10,
	0x06, 0xa9, 0xd3, 0x83, 0xd6, 0x4b, 0x8b, 0x67, 0xa0, 0xe0, 0xfc, 0xa7, 0x6b, 0x66, 0xb8, 0x4d,
	0xb8, 0x53, 0x0c, 0xbd, 0x2a, 0x88, 0xef, 0x32, 0x8b, 0xef, 0x73, 0xa2, 0x18, 0x1b, 0xec, 0x56,
	0x88, 0xfe, 0xfd, 0x83, 0x1e, 0x60, 0x2b, 0x0c, 0x60, 0xf7, 0x4c, 0x58, 0xef, 0x54, 0x2e, 0x7d,
	0x51, 0xbc, 0xe8, 0xd2, 0xf7, 0xcf, 0x53, 0x85, 0x0b, 0x7d, 0xfc, 0x60, 0xdc, 0x4f, 0x70, 0x01,
	0x3c, 0x00, 0x56, 0x87, 0xb4, 0x04, 0x3e, 0xee, 0x61, 0x45, 0x3f, 0x36, 0x5e, 0x97, 0x49, 0xe4,
	0x4e, 0x05, 0x1d, 0x3f, 0x02, 0xd7, 0xf8, 0x11, 0x4f, 0x01, 0x58, 0x78, 0xa7, 0xaf, 0xca, 0x16,
	0xf6, 0x56, 0xcd, 0x40, 0x0e, 0xfa, 0x77, 0x07, 0x43, 0x38, 0xf2, 0xfb, 0xc3, 0x27, 0x36, 0xcb,
	0x37, 0xd8, 0x0f, 0x00, 0xf2, 0x21, 0x7d, 0x6c, 0xfc, 0x66, 0x0e, 0x8e, 0xb8, 0xea, 0xe8, 0xc3,
	0xd4, 0xdf, 0xbf, 0x46, 0x88, 0xa7, 0x38, 0x08, 0x70, 0xcf, 0x23, 0x3e, 0x91, 0xaf, 0xc8, 0xeb,
	0xe1, 0x88, 0x4b, 0xd4, 0x05, 0xef, 0x48, 0x28, 0x98, 0xc5, 0xf4, 0x2f, 0xc7, 0xdb, 0xbf, 0x38,
	0x5a, 0x07, 0x8e, 0xbe, 0xa5, 0x2f, 0x18, 0xdf, 0x13, 0xe0, 0x98, 0xdb, 0x3e, 0x5d, 0x5b, 0xdf,
	0x90, 0xc0, 0xf8, 0x4f, 0x89, 0xbd, 0x31, 0xdd, 0xb2, 0xee, 0x67, 0x71, 0x82, 0x1f, 0xa3, 0x71,
	0x34, 0x99, 0x7c, 0x74, 0xa4, 0x8f, 0xf6, 0x47, 0x03, 0x68, 0xd3, 0x95, 0xb9, 0x3b, 0x05, 0xb0,
	0x0f, 0x8e, 0x1b, 0xdf, 0x0a, 0x2d, 0xa4, 0x8e, 0xdb, 0x21, 0xad, 0xd1, 0xdf, 0xc8, 0xc1, 0x35,
	0xce, 0xfa, 0xe1, 0x12, 0xd2, 0xea, 0xbb, 0x53, 0xf9, 0xa3, 0x53, 0x19, 0xae, 0xcf, 0x86, 0x82,
	0xde, 0x0f, 0x0c, 0xd6, 0x53, 0x21, 0x83, 0xb5, 0xec, 0x10, 0x26, 0xd1, 0xd2, 0xcc, 0xae, 0x2d,
	0x3f, 0xb4, 0x6b, 0x63, 0x1c, 0x79, 0x3c, 0x9f, 0x95, 0x8a, 0x85, 0xf1, 0x4b, 0xe9, 0x3e, 0x56,
	0x24, 0xb2, 0x30, 0xf8, 0x1d, 0x15, 0xe2, 0x74, 0x14, 0x7d, 0xc2, 0x13, 0xab, 0x17, 0x30, 0x62,
	0x75, 0xee, 0xe0, 0x1d, 0x99, 0xc2, 0x61, 0x71, 0x0e, 0xd0, 0x28, 0x5a, 0xe8, 0x8a, 0xf0, 0xd3,
	0x2b, 0x62, 0x7f, 0x11, 0x9c, 0x78, 0x5e, 0xc0, 0x8a, 0x58, 0x2d, 0x2e, 0x32, 0x09, 0x2e, 0x1e,
	0x9f, 0xf2, 0xa4, 0xe5, 0x5f, 0x30, 0xd2, 0xf2, 0x40, 0x22, 0x34, 0x4d, 0xc1, 0x32, 0x39, 0x44,
	0x60, 0xe8, 0xa2, 0xf2, 0xe6, 0xa9, 0x08, 0x0c, 0x82, 0x19, 0x47, 0x04, 0xbc, 0x2f, 0x06, 0x2f,
	0x3d, 0x3d, 0xa1, 0x48, 0xf0, 0xdb, 0x31, 0x31, 0xa1, 0x38, 0xa4, 0x55, 0xea, 0x8f, 0x05, 0x78,
	0x82, 0x4b, 0x48, 0x43, 0x31, 0xad, 0xca, 0xae, 0xac, 0xa8, 0xf2, 0xba, 0x8a, 0x93, 0xf0, 0x8e,
	0xf0, 0xbf, 0x82, 0xa0, 0x5d, 0x64, 0x41, 0x7b, 0x1e, 0xcf, 0xd2, 0xcd, 0x50, 0x14, 0x82, 0xd7,
	0x1d, 0x30, 0xeb, 0x0a, 0x98, 0x7b, 0x6d, 0x3c, 0x74, 0x57, 0xea, 0x97, 0x44, 0xff, 0xd9, 0x03,
	0xee, 0x41, 0x06, 0xb8, 0xda, 0x41, 0xe9, 0x8a, 0x87, 0x59, 0x63, 0x02, 0x93, 0x94, 0x79, 0x38,
	0xd1, 0x6c, 0x75, 0xd6, 0x2a, 0x6b, 0x8b, 0x95, 0x4e, 0xe5, 0x62, 0xbd, 0x76, 0x69, 0x6d, 0xa1,
	0xd1, 0xaa, 0x5e, 0x28, 0x09, 0xe8, 0xdf, 0x0a, 0x30, 0xdb, 0xc6, 0x56, 0x5b, 0x1f, 0x18, 0xdd,
	0xa4, 0xce, 0x2e, 0x4c, 0x52, 0x19, 0x0d, 0x47, 0x44, 0x53, 0x71, 0x1d, 0x41, 0xfb, 0x1c, 0xf4,
	0xa8, 0x1b, 0x37, 0xfa, 0x72, 0x09, 0x3b, 0x82, 0x1e, 0x4f, 0x42, 0xfa, 0x83, 0xed, 0x1d, 0x02,
	0x08, 0xe7, 0xb0, 0x85, 0xde, 0x24, 0x40, 0x9e, 0xdc, 0xfd, 0x4c, 0xc8, 0x19, 0x2d, 0xaf, 0x9b,
	0x53, 0xf4, 0xf6, 0x20, 0x6c, 0x15, 0x16, 0xb6, 0x51, 0x6e, 0x01, 0xcf, 0x61, 0x7a, 0x49, 0x35,
	0x91, 0xb9, 0xf2, 0x9d, 0x1e, 0x5a, 0x8b, 0x0c, 0x5a, 0xcf, 0x8c, 0xd1, 0x72, 0xfa, 0x20, 0xdd,
	0x05, 0xc7, 0x57, 0xb5, 0x9e, 0x2e, 0xe1, 0x9e, 0x5e, 0xd5, 0x07, 0x9a, 0x85, 0x89, 0xd3, 0xa2,
	0x81, 0xd6, 0xd3, 0x09, 0xb9, 0x79, 0x89, 0xfc, 0xb7, 0xf3, 0x0c, 0xdc, 0xd3, 0x49, 0xab, 0x79,
	0x89, 0xfc, 0x47, 0x6f, 0x16, 0x20, 0x67, 0xbf, 0x8b, 0x9e, 0xc6, 0x09, 0x2b, 0xfa, 0xef, 0x31,
	0xdd, 0x4a, 0xda, 0xb5, 0x27, 0xb2, 0x65, 0xbe, 0x0f, 0x66, 0xba, 0x4e, 0xef, 0x5c, 0x47, 0x0d,
	0xa7, 0x43, 0x9a, 0x0b, 0x30, 0x42, 0xf2, 0xde, 0x09, 0x1c, 0x48, 0x8c, 0x77, 0x2e, 0x39, 0x82,
	0xe8, 0x78, 0x30, 0x2e, 0x4e, 0x30, 0x49, 0x96, 0xe0, 0x68, 0xb5, 0xd2, 0x5c, 0xb3, 0x27, 0xca,
	0xe5, 0xd6, 0xc5, 0x5a, 0x49, 0x20, 0xe8, 0xd8, 0x9d, 0x49, 0x0f, 0x1d, 0xbb, 0xf6, 0x9f, 0x3a,
	0x74, 0x46, 0x10, 0x7d, 0x18, 0xe8, 0xbc, 0x5b, 0x80, 0x5c, 0xab, 0x8f, 0xb5, 0x84, 0xee, 0xa0,
	0x5a, 0x86, 0xdc, 0xc5, 0xde, 0xa9, 0x83, 0x9b, 0x44, 0x7f, 0x18, 0x13, 0x51, 0x9b, 0xa2, 0x44,
	0xe6, 0xbe, 0xcf, 0xc7, 0x40, 0x64, 0x44, 0xa3, 0xf1, 0x10, 0xf9, 0xf9, 0x09, 0x10, 0x99, 0x83,
	0x59, 0x1b, 0x8d, 0xa5, 0xd6, 0x6a, 0x73, 0xb1, 0x24, 0x88, 0x4f, 0x84, 0x27, 0x54, 0x9a, 0x0f,
	0x12, 0x53, 0xd7, 0x66, 0xad, 0xb6, 0xd8, 0x5e, 0x5b, 0x5d, 0x39, 0x27, 0x55, 0x16, 0x6b, 0x25,
	0x20, 0x48, 0xb5, 0xb7, 0xf4, 0xcb, 0x57, 0x16, 0x52, 0x36, 0x45, 0x53, 0x47, 0x6a, 0x44, 0xa3,
	0x57, 0x12, 0x52, 0x5f, 0xcc, 0xc2, 0xf1, 0x73, 0xd8, 0x5a, 0x19, 0xac, 0xab, 0x4a, 0xf7, 0x12,
	0x5e, 0x5f, 0x95, 0x1a, 0xe8, 0xa9, 0x3e, 0x68, 0xa1, 0x81, 0x7a, 0xd0, 0x6b, 0x63, 0x5e, 0xb1,
	0x18, 0x6a, 0x24, 0x04, 0x07, 0x6a, 0xf5, 0x98, 0xf5, 0xed, 0x5f, 0xe3, 0x5c, 0xa3, 0x88, 0x6e,
	0x23, 0xfd, 0x7d, 0xc1, 0x5b, 0x04, 0x38, 0x6e, 0x8f, 0xcc, 0x05, 0x03, 0xcb, 0xbd, 0xae, 0x31,
	0xd8, 0x59, 0x37, 0x63, 0x7d, 0x23, 0xb9, 0x72, 0x9e, 0x65, 0xe5, 0xfc, 0x73, 0x31, 0x59, 0x3d,
	0x44, 0x42, 0xca, 0x16, 0x99, 0x71, 0x00, 0x8a, 0xa6, 0x2c, 0x7d, 0x80, 0x5e, 0x22, 0xc0, 0xb1,
	0x36, 0xb6, 0x42, 0xf0, 0xb9, 0x01, 0xe6, 0xd6, 0xfd, 0x27, 0x1e, 0x46, 0x6c, 0xa6, 0x2d, 0xa2,
	0x8a, 0xe7, 0x40, 0xd4, 0xfe, 0x3b, 0x89, 0x33, 0x89, 0xf1, 0xf0, 0xa4, 0xea, 0x4c, 0xe2, 0x30,
	0x31, 0xf8, 0xbe, 0x00, 0x05, 0x7a, 0x24, 0xfd, 0xde, 0x44, 0x8c, 0xac, 0x63, 0x84, 0xda, 0x38,
	0x48, 0x84, 0xdc, 0x8f, 0xc6, 0xf4, 0x9a, 0x19, 0x79, 0x36, 0x9d, 0xd4, 0xe0, 0x8b, 0xe3, 0x4f,
	0xf3, 0x90, 0xce, 0xa8, 0xbf, 0x9f, 0x03, 0x70, 0x9a, 0x26, 0x0e, 0xc8, 0x5e, 0xca, 0x1d, 0xb6,
	0x63, 0x82, 0xd8, 0xd8, 0xac, 0xb9, 0x41, 0x7e, 0xd8, 0xdc, 0x80, 0xdb, 0x56, 0x3f, 0x9e, 0x68,
	0x04, 0x5c, 0x4d, 0x16, 0xf8, 0x5c, 0x4d, 0x7e, 0x2d, 0xa6, 0xab, 0x49, 0x9f, 0x7f, 0xb1, 0xe5,
	0x29, 0xd8, 0x65, 0x61, 0xa8, 0xcb, 0xf1, 0x34, 0x29, 0x71, 0x1c, 0x54, 0x86, 0x12, 0x9c, 0xbe,
	0xbc, 0xfd, 0xa7, 0x1c, 0xcc, 0x3a, 0xcd, 0xb7, 0xb1, 0x85, 0xbe, 0x90, 0xc8, 0x14, 0x13, 0xa2,
	0xe3, 0x0a, 0x8a, 0x68, 0x8e, 0x53, 0x44, 0x0f, 0x10, 0x9a, 0xfd, 0x47, 0x31, 0x55, 0x33, 0x1e,
	0x17, 0x0e, 0x51, 0x68, 0x3e, 0x13, 0x43, 0xa1, 0x13, 0x46, 0xef, 0x21, 0xdf, 0xe0, 0xfb, 0x5e,
	0x16, 0x0a, 0xab, 0x9a, 0xaa, 0x68, 0xdb, 0xa8, 0x9a, 0x40, 0x60, 0xb6, 0xf8, 0xee, 0x97, 0x49,
	0xdb, 0xd3, 0x77, 0xbf, 0x3c, 0xaa, 0xd9, 0x29, 0xb8, 0x09, 0xcb, 0x42, 0xbe, 0xaa, 0xea, 0x66,
	0x22, 0xa7, 0x0b, 0xdf, 0xcb, 0xc4, 0x8b, 0x29, 0x41, 0x1a, 0x0e, 0x31, 0xd7, 0x8c, 0x13, 0xb7,
	0x61, 0x54, 0x3d, 0xe9, 0xb3, 0xee, 0xaf, 0x8f, 0xc2, 0xec, 0x25, 0xdd, 0xd8, 0x36, 0xfb, 0x72,
	0x17, 0xa3, 0x8f, 0x67, 0x01, 0xce, 0x61, 0xab, 0x3a, 0x30, 0x0c, 0x1b, 0xfa, 0x59, 0x8f, 0x9b,
	0xac, 0x47, 0xea, 0xc8, 0xfd, 0xaa, 0x57, 0x5b, 0xd9, 0xaf, 0x29, 0xdc, 0xbf, 0xfe, 0x65, 0xb7,
	0xb4, 0x07, 0x44, 0x30, 0x8b, 0x73, 0x8f, 0xca, 0xd1, 0x64, 0xfa, 0x9c, 0xfc, 0x60, 0x16, 0x0a,
	0xe7, 0xb0, 0x55, 0x51, 0xd5, 0x20, 0xdf, 0xde, 0xc8, 0xbd, 0x6a, 0x33, 0x9d, 0xa8, 0xa8, 0x6a,
	0x08, 0xcf, 0x4e, 0xc3, 0xd1, 0x00, 0x83, 0xdc, 0x99, 0x82, 0xc9, 0xe3, 0x5c, 0x75, 0xc7, 0x34,
	0x98, 0x3e, 0xc7, 0xfe, 0x30, 0xeb, 0xed, 0xea, 0x9f, 0xe4, 0x8f, 0xdb, 0x11, 0x91, 0x61, 0xd0,
	0xeb, 0x27, 0xe0, 0x62, 0xe4, 0x5e, 0x7a, 0xbc, 0xe4, 0xc5, 0xe5, 0xe1, 0x21, 0xed, 0x94, 0xbf,
	0x97, 0x85, 0x52, 0x1b, 0x5b, 0x75, 0xf3, 0xbc, 0xb2, 0xb9, 0xa5, 0x2a, 0x9b, 0x5b, 0x16, 0xee,
	0xa1, 0x0b, 0x3e, 0x37, 0x11, 0xcc, 0x38, 0xd7, 0xf4, 0xbd, 0x49, 0xd0, 0x4b, 0x3b, 0xc1, 0x85,
	0x02, 0xef, 0x11, 0x9a, 0x48, 0x70, 0xa1, 0x60, 0x65, 0xaf, 0xe0, 0xbe, 0xe0, 0xe9, 0x33, 0x63,
	0x98, 0xa2, 0x90, 0xe9, 0x91, 0xcf, 0x44, 0x92, 0xbb, 0xda, 0x29, 0x5c, 0x3e, 0xc8, 0x42, 0xa1,
	0x4d, 0xe2, 0xca, 0xa0, 0x9f, 0xf5, 0x79, 0x3c, 0x24, 0x4c, 0x99, 0xfd, 0xc2, 0xf4, 0x7f, 0x32,
	0xf1, 0xe5, 0xd7, 0x69, 0x27, 0x84, 0x73, 0x71, 0xa5, 0x73, 0x64, 0x65, 0x53, 0x70, 0xe0, 0x32,
	0x03, 0x85, 0x4b, 0xb2, 0xaa, 0x62, 0x0b, 0x7d, 0xd3, 0x1f, 0xec, 0x37, 0x32, 0xe2, 0x69, 0xe8,
	0xba, 0x13, 0xd4, 0x85, 0x8a, 0xa7, 0x9b, 0x46, 0xef, 0xe3, 0x8e, 0x4e, 0xea, 0x34, 0x11, 0x3d,
	0xe2, 0x11, 0xcc, 0xec, 0x68, 0x78, 0x47, 0xd7, 0x94, 0xae, 0xbb, 0x55, 0x77, 0xd3, 0xe8, 0x8f,
	0xb8, 0x22, 0x8e, 0x46, 0xb5, 0x12, 0x8f, 0x95, 0xed, 0x09, 0xb6, 0x9b, 0x4f, 0x86, 0x6b, 0x97,
	0x2a, 0xf5, 0x46, 0x6d, 0x71, 0xad, 0xd3, 0x5a, 0xab, 0x4a, 0xb5, 0x4a, 0xa7, 0xb6, 0xd6, 0x68,
	0x55, 0x2b, 0x8d, 0x35, 0xa9, 0xb6, 0xd2, 0x2a, 0x61, 0xf4, 0x6d, 0xf2, 0x91, 0xdc, 0xd5, 0x77,
	0xb1, 0x11, 0xdc, 0x06, 0x45, 0x70, 0x38, 0x92, 0x27, 0xaf, 0xe3, 0x0e, 0x41, 0x41, 0xf9, 0x42,
	0xdb, 0x0e, 0x11, 0xd8, 0xff, 0xc0, 0x15, 0x54, 0x22, 0xb2, 0xaa, 0x2b, 0x80, 0xc7, 0x3f, 0xca,
	0x42, 0xb1, 0xaa, 0x6b, 0xbb, 0xd8, 0xb0, 0xd0, 0xfd, 0x0c, 0x8f, 0x3d, 0x3e, 0x66, 0x58, 0x3e,
	0xda, 0x1b, 0x4d, 0xac, 0x59, 0x86, 0xde, 0xdf, 0x73, 0x37, 0x9a, 0x34, 0xc9, 0x3a, 0xb0, 0xe1,
	0xe1, 0x30, 0x6d, 0x39, 0xfc, 0xcb, 0x6c, 0x74, 0x43, 0x0c, 0x79, 0xc2, 0x10, 0xcc, 0xef, 0x88,
	0x83, 0xcb, 0x68, 0x02, 0xa6, 0x60, 0xe0, 0x70, 0x02, 0x8a, 0x95, 0x2e, 0x39, 0x86, 0x44, 0xdf,
	0xcd, 0x40, 0xa1, 0xaa, 0x6b, 0x1b, 0xca, 0xa6, 0x78, 0x13, 0x1c, 0xc3, 0x9a, 0xbc, 0xae, 0x62,
	0xd7, 0x06, 0x83, 0xd0, 0x3e, 0x23, 0x0d, 0xe5, 0xda, 0x44, 0xd1, 0x1c, 0xbc, 0x3e, 0xd8, 0xa4,
	0xab, 0x5c, 0x30, 0x4b, 0xbc, 0x0f, 0x90, 0x93, 0x94, 0xb0, 0x8a, 0x65, 0x13, 0x57, 0xb7, 0x64,
	0x4d, 0xc3, 0x6a, 0xfb, 0xb2, 0x62, 0x75, 0xb7, 0xa8, 0xc3, 0xd9, 0x88, 0x12, 0xf6, 0xa6, 0xcc,
	0x79, 0xda, 0xb6, 0x67, 0x5b, 0x93, 0x46, 0x7d, 0x63, 0xf2, 0xc4, 0x67, 0x40, 0x1e, 0x3f, 0x64,
	0x19, 0xf2, 0x7c, 0x2f, 0xfa, 0xab, 0xdf, 0x29, 0x85, 0xbe, 0x9d, 0xf7, 0xe6, 0xcb, 0x5f, 0x88,
	0xdc, 0x1c, 0x89, 0xb7, 0xc0, 0x71, 0x79, 0x57, 0xb6, 0x64, 0xa3, 0xe1, 0x79, 0x7a, 0x20, 0x7c,
	0x3f, 0x7f, 0x95, 0x34, 0xfc, 0x40, 0xbc, 0x19, 0x8e, 0xcb, 0x6a, 0x7f, 0x4b, 0xae, 0x6b, 0xbb,
	0x8a, 0x85, 0x6d, 0x20, 0xe6, 0x4f, 0x90, 0xaa, 0x86, 0xb3, 0x17, 0x66, 0xa0, 0xe0, 0xbc, 0x8c,
	0xbe, 0x9a, 0xe3, 0x95, 0x53, 0x8a, 0x51, 0xf4, 0x44, 0xfc, 0x4c, 0x28, 0xca, 0x4e, 0xb9, 0x7d,
	0xdf, 0x9f, 0x8e, 0x2e, 0x83, 0xd6, 0x22, 0xb9, 0xc5, 0xc4, 0xdb, 0xa1, 0xd0, 0x25, 0x88, 0x53,
	0x9d, 0xde, 0xb5, 0xa3, 0x1b, 0x25, 0x45, 0x24, 0x5a, 0x14, 0xbd, 0x5d, 0xe0, 0x11, 0xec, 0x48,
	0x8a, 0xe3, 0x09, 0xf6, 0x87, 0xb2, 0x13, 0xcc, 0x38, 0xb7, 0xc2, 0xcd, 0x95, 0x6a, 0xb5, 0xb5,
	0xda, 0xec, 0xd0, 0xf9, 0x66, 0x71, 0x6d, 0x61, 0xb5, 0xb3, 0xe6, 0xcf, 0x42, 0xed, 0x4e, 0x45,
	0xea, 0xac, 0x35, 0x5b, 0x8b, 0xb5, 0x92, 0x8d, 0xf4, 0x4d, 0x63, 0x4a, 0xd7, 0x3a, 0x6b, 0xcd,
	0xca, 0x72, 0xad, 0xb4, 0xc1, 0x51, 0x73, 0xad, 0xb3, 0x56, 0xb9, 0x58, 0xe9, 0x54, 0xa4, 0xd2,
	0x26, 0x3b, 0xf3, 0xb5, 0x3b, 0xad, 0x95, 0x35, 0x69, 0xb5, 0xd9, 0xac, 0x37, 0xcf, 0x39, 0x4d,
	0x6f, 0x89, 0x27, 0xe0, 0xb8, 0x43, 0xf7, 0xc5, 0x7a, 0xa7, 0xb6, 0x56, 0xb5, 0x33, 0x7f, 0xa9,
	0x28, 0x1e, 0x83, 0xd9, 0x66, 0xad, 0x43, 0x3b, 0xf7, 0xf2, 0xa2, 0x78, 0x2d, 0x9c, 0xb4, 0xd3,
	0xd5, 0x56, 0xb3, 0x59, 0xab, 0x76, 0xea, 0xad, 0xe6, 0x9a, 0x54, 0x5b, 0x5a, 0x6d, 0xd7, 0x16,
	0x4b, 0xbf, 0x5c, 0x14, 0x4b, 0x70, 0xc4, 0x7e, 0xd8, 0x5a, 0x5a, 0x6a, 0xd4, 0x9b, 0xb5, 0xd2,
	0xc3, 0x45, 0xf4, 0xea, 0x9c, 0xbf, 0x64, 0x05, 0xbe, 0x99, 0xfe, 0x4e, 0xe0, 0xd5, 0x59, 0xb9,
	0xf0, 0x45, 0xaf, 0x3d, 0xbf, 0x23, 0xf0, 0xe8, 0x93, 0xa2, 0xeb, 0x8a, 0x27, 0x0b, 0x1f, 0x99,
	0x44, 0x16, 0x9e, 0x00, 0x57, 0x37, 0x5b, 0x6b, 0x14, 0xb4, 0x36, 0x3d, 0x88, 0xb5, 0x5b, 0xbb,
	0xae, 0x59, 0x73, 0x80, 0x91, 0x6a, 0xd5, 0xd6, 0xc5, 0x9a, 0xb4, 0x76, 0xa9, 0xd2, 0x68, 0xd4,
	0x3a, 0x6b, 0x4b, 0x75, 0xa9, 0xdd, 0x29, 0x6d, 0x8c, 0x5b, 0xb6, 0x36, 0xc5, 0xa7, 0xc2, 0x93,
	0xfd, 0xf4, 0x5a, 0xed, 0xf9, 0xf5, 0x76, 0xa7, 0x4d, 0xa4, 0xa1, 0xda, 0x92, 0xa4, 0xd5, 0x95,
	0x4e, 0x6d, 0xb1, 0xb4, 0x25, 0x9e, 0x04, 0xd1, 0xaf, 0x45, 0x5a, 0x6d, 0x3a, 0xc8, 0x2b, 0x76,
	0xfb, 0xb4, 0x3d, 0xb7, 0xf9, 0x66, 0xab, 0xb3, 0xb6, 0x52, 0x93, 0x96, 0x5a, 0xd2, 0x72, 0x6d,
	0xb1, 0xf4, 0xc2, 0x71, 0xc2, 0xb3, 0x2d, 0xde, 0x04, 0xa7, 0x2b, 0xcd, 0x56, 0xe7, 0x7c, 0x4d,
	0x5a, 0x73, 0xcf, 0x94, 0x57, 0xa4, 0x56, 0xb5, 0xd6, 0x6e, 0xaf, 0xd5, 0xdb, 0x6e, 0xe1, 0x92,
	0x8a, 0x3e, 0x95, 0xf7, 0xb6, 0xd7, 0x77, 0xf8, 0x73, 0xde, 0x31, 0xc8, 0x2a, 0xee, 0xae, 0x3a,
	0xab, 0xf4, 0x98, 0x1d, 0x4d, 0x76, 0x68, 0xcf, 0xf8, 0x8f, 0xb1, 0xe7, 0xaa, 0xa8, 0x6d, 0xf6,
	0xb4, 0xe6, 0xaa, 0xcf, 0xc6, 0x9a, 0xab, 0x12, 0xd8, 0xcb, 0xff, 0x79, 0x36, 0x85, 0xdd, 0x11,
	0x8f, 0x98, 0x6d, 0x84, 0x88, 0xd9, 0xd0, 0x0c, 0xb4, 0x54, 0x6f, 0x2e, 0xba, 0x23, 0x61, 0xad,
	0xde, 0x5c, 0x6a, 0x95, 0xb6, 0xc4, 0x32, 0xdc, 0x12, 0xa8, 0xdd, 0x96, 0x41, 0xda, 0x42, 0xa5,
	0xb9, 0xb8, 0xb6, 0xdc, 0xac, 0x2d, 0xb7, 0x9a, 0xf5, 0x2a, 0xc9, 0x6f, 0xd7, 0x3a, 0x8e, 0xdc,
	0x0e, 0x49, 0x65, 0xbb, 0x56, 0x91, 0xaa, 0xe7, 0x89, 0x00, 0x2f, 0xd6, 0x4a, 0x2f, 0x14, 0x9f,
	0x06, 0x4f, 0x0d, 0x90, 0x42, 0x85, 0x7b, 0x45, 0xaa, 0x2d, 0xd6, 0x96, 0xea, 0x4d, 0x7b, 0xbe,
	0x6c, 0xb4, 0xaa, 0x17, 0xda, 0x31, 0xe4, 0xf7, 0x1f, 0xb2, 0x90, 0x6b, 0x5b, 0x7a, 0x1f, 0x3d,
	0xdd, 0x97, 0xde, 0x53, 0x00, 0x06, 0xde, 0xd1, 0x77, 0xc9, 0x76, 0x84, 0x6e, 0x50, 0x02, 0x39,
	0xe8, 0x3f, 0x72, 0x6b, 0x76, 0x3d, 0xfc, 0x2d, 0xbd, 0x1f, 0x32, 0xd3, 0xfd, 0x98, 0x4b, 0x57,
	0x1b, 0x51, 0x51, 0x3c, 0x31, 0x7a, 0x65, 0x66, 0x02, 0x31, 0x42, 0x70, 0xd2, 0x43, 0xb6, 0x4d,
	0xf0, 0x72, 0x19, 0x88, 0xc5, 0x6b, 0xe0, 0x67, 0x86, 0x30, 0x23, 0x50, 0x6d, 0x88, 0x4f, 0x81,
	0x27, 0x05, 0xa1, 0x5a, 0x6e, 0x5d, 0xac, 0x79, 0xf2, 0xb1, 0x58, 0xe9, 0x54, 0x4a, 0x9b, 0xe8,
	0xd3, 0x02, 0x08, 0x0d, 0x7d, 0x13, 0x3d, 0x2a, 0x40, 0xae, 0x8d, 0xb5, 0x1e, 0x73, 0x52, 0x3c,
	0x0f, 0xc5, 0x1d, 0x6c, 0x9a, 0xf2, 0xa6, 0xbb, 0x75, 0x72, 0x93, 0xe2, 0x5d, 0x90, 0x57, 0xf1,
	0x2e, 0x76, 0xec, 0x47, 0x8e, 0x9d, 0x7d, 0x2a, 0xc3, 0xa9, 0x86, 0xbe, 0x59, 0xb6, 0xeb, 0xf2,
	0xa2, 0x19, 0x37, 0xec, 0xa2, 0x92, 0xf3, 0xc6, 0xe9, 0x07, 0x20, 0x4f, 0xd2, 0xe2, 0x2c, 0xe4,
	0x17, 0x6b, 0x0b, 0xab, 0xe7, 0x4a, 0x57, 0xd9, 0x7f, 0xdd, 0x7e, 0xcf, 0x42, 0x7e, 0xa9, 0xd2,
	0xa9, 0x34, 0x4a, 0x59, 0x9b, 0x3f, 0x44, 0x8a, 0x05, 0x3b, 0x73, 0xa5, 0xd2, 0xac, 0x57, 0x4b,
	0x39, 0xf1, 0x08, 0x14, 0x2f, 0x55, 0x24, 0xd2, 0xf3, 0x3c, 0x7a, 0x49, 0x50, 0x0c, 0xee, 0x66,
	0xc5, 0xe0, 0x86, 0x30, 0x9a, 0x46, 0x89, 0xc0, 0xc7, 0x3c, 0x11, 0xb8, 0x97, 0x11, 0x81, 0xa7,
	0xf3, 0x54, 0x12, 0x0f, 0xfe, 0xe6, 0x41, 0xad, 0x8c, 0xb0, 0xcd, 0x83, 0x4e, 0x7d, 0xb9, 0xd6,
	0x5a, 0xed, 0x94, 0x36, 0xd0, 0xdf, 0x64, 0xa1, 0x78, 0x11, 0x1b, 0xa6, 0xa2, 0x6b, 0xe8, 0xbf,
	0x66, 0x1d, 0x9b, 0xe6, 0xc0, 0xb6, 0xe0, 0x2b, 0xdc, 0xc1, 0xee, 0x69, 0x25, 0xc4, 0xda, 0x37,
	0xf4, 0x63, 0x69, 0xd7, 0x29, 0xe4, 0x7e, 0x2c, 0xd1, 0xa4, 0xfd, 0x24, 0x78, 0x82, 0x3c, 0xeb,
	0x47, 0x81, 0xfb, 0x0a, 0x97, 0x32, 0x3f, 0xbc, 0xed, 0x78, 0xcc, 0xed, 0x4d, 0xc0, 0xdc, 0x13,
	0x50, 0xba, 0x58, 0x93, 0xda, 0xf6, 0xbe, 0xab, 0xde, 0x5e, 0xab, 0x2d, 0xaf, 0x74, 0x1e, 0x2c,
	0x09, 0x91, 0x2c, 0x7f, 0x9b, 0x1b, 0x56, 0xe0, 0xf5, 0x02, 0x14, 0x5b, 0x1b, 0x1b, 0xc4, 0x8f,
	0x5d, 0x2d, 0x7c, 0xed, 0xbd, 0x05, 0x4a, 0x8a, 0xd6, 0x55, 0x07, 0x3d, 0xdc, 0xd4, 0xad, 0x15,
	0x45, 0xd3, 0x3c, 0xad, 0xe1, 0xbe, 0x7c, 0xf4, 0x18, 0xf7, 0xcc, 0x46, 0x9c, 0xae, 0xd1, 0xd6,
	0x43, 0x00, 0xbb, 0x09, 0x8e, 0xad, 0xef, 0x59, 0xd8, 0xa4, 0xa5, 0x68, 0xb3, 0x39, 0x69, 0x28,
	0x17, 0xfd, 0x29, 0xd7, 0x0c, 0x18, 0xd1, 0x60, 0x3c, 0x94, 0xe4, 0xc9, 0x50, 0xb2, 0x67, 0x35,
	0x67, 0xa9, 0xb2, 0xb7, 0xf7, 0xb5, 0xc5, 0xd2, 0x26, 0x99, 0xfa, 0xea, 0x0d, 0x27, 0xf7, 0xc1,
	0x5a, 0x67, 0x6d, 0xa5, 0xde, 0x6c, 0xda, 0xfb, 0x32, 0x7b, 0x73, 0x30, 0x63, 0xd3, 0xdb, 0x50,
	0x4c, 0x0b, 0x7d, 0x2c, 0x00, 0x53, 0x8b, 0x99, 0xde, 0x74, 0x4d, 0xdd, 0xab, 0xf7, 0xcc, 0xf9,
	0x0c, 0x39, 0x0f, 0x70, 0x93, 0xb1, 0x00, 0xfb, 0x6b, 0x6e, 0x2d, 0xbb, 0x4b, 0xcf, 0x78, 0xd0,
	0x36, 0x14, 0x75, 0x18, 0xb4, 0xbc, 0x34, 0x94, 0x3b, 0x02, 0x5c, 0x61, 0x24, 0xb8, 0x9f, 0xe0,
	0xd2, 0x7a, 0x8e, 0x21, 0x2e, 0x1e, 0xc0, 0xe7, 0x93, 0x02, 0x18, 0xfd, 0x5a, 0x16, 0x66, 0xda,
	0x5b, 0x03, 0x8b, 0xc4, 0xbd, 0x0e, 0x4c, 0x6b, 0xff, 0x98, 0xe1, 0x9d, 0xf9, 0xdd, 0xb7, 0x43,
	0x66, 0xfe, 0x0f, 0x73, 0xcd, 0xfc, 0x21, 0x95, 0x1c, 0x0e, 0x57, 0x30, 0xfa, 0x6e, 0xce, 0x55,
	0xe7, 0xa0, 0xaf, 0xe7, 0xf6, 0x4d, 0xf9, 0x9f, 0xcb, 0xf1, 0x5a, 0xeb, 0x3a, 0x75, 0x44, 0xcc,
	0xf8, 0xd7, 0xc3, 0x91, 0x2d, 0x9d, 0x86, 0xe0, 0xf7, 0x4f, 0x7c, 0x02, 0x59, 0xb6, 0x14, 0xca,
	0x4e, 0x98, 0x3f, 0xd6, 0xa5, 0xfb, 0x50, 0xae, 0x5d, 0xae, 0x6f, 0xe8, 0xb6, 0x08, 0xbb, 0xe5,
	0x9c, 0x1b, 0x87, 0x43, 0xb9, 0xe2, 0xad, 0x70, 0xf5, 0x8e, 0x6c, 0x6c, 0x63, 0xab, 0xaf, 0xca,
	0x5d, 0xe2, 0x2c, 0xd3, 0xb3, 0x2f, 0xda, 0xff, 0x40, 0x7c, 0x16, 0x3c, 0x21, 0x90, 0xe9, 0xde,
	0x08, 0xab, 0xf7, 0x88, 0x79, 0xd0, 0xac, 0x34, 0xfa, 0xe1, 0xd0, 0x5b, 0x1d, 0xdf, 0x8e, 0xa9,
	0xb8, 0xef, 0xad, 0x0e, 0x63, 0xd2, 0xd4, 0xc3, 0xbb, 0x0a, 0x39, 0xad, 0x98, 0x71, 0xbe, 0xa0,
	0xdc, 0xb4, 0xbd, 0x5f, 0xdd, 0x94, 0x2d, 0x7c, 0x59, 0xde, 0x5b, 0x35, 0xd4, 0x79, 0xec, 0x98,
	0x43, 0xf9, 0x39, 0xe8, 0x23, 0x5c, 0x76, 0xcc, 0xa1, 0x70, 0x1c, 0x96, 0x9c, 0x7d, 0x25, 0x0b,
	0xb9, 0x15, 0x45, 0xdb, 0x0c, 0x3a, 0x51, 0x3e, 0x01, 0x79, 0x45, 0xeb, 0xe1, 0x87, 0xe8, 0x05,
	0x1c, 0x27, 0x21, 0x9e, 0x85, 0x13, 0xda, 0x60, 0x67, 0x1d, 0x1b, 0xad, 0x0d, 0x62, 0x07, 0x61,
	0x76, 0x74, 0x7b, 0xa7, 0x44, 0xa7, 0xae, 0x91, 0xcf, 0xd0, 0xff, 0x0e, 0x8e, 0xe1, 0x67, 0xb3,
	0x72, 0x7a, 0x3d, 0xc3, 0x18, 0x9b, 0x86, 0x10, 0x09, 0xf5, 0xc8, 0xc9, 0x06, 0xc8, 0x41, 0x6f,
	0xf0, 0xf8, 0x7d, 0x17, 0xc3, 0xef, 0x1b, 0xc7, 0x55, 0x9b, 0xbe, 0x5a, 0xf6, 0x9d, 0x59, 0x28,
	0xae, 0x18, 0x7a, 0x17, 0x9b, 0x26, 0x7a, 0x7d, 0x16, 0x0a, 0x55, 0x59, 0xeb, 0x62, 0x15, 0x3d,
	0x31, 0x74, 0xfb, 0x80, 0x7e, 0x98, 0xe1, 0xfd, 0x3c, 0xa7, 0xf5, 0x96, 0x9d, 0x3a, 0x43, 0x66,
	0x3c, 0x3e, 0xe5, 0x75, 0x64, 0x55, 0xe9, 0x73, 0xe9, 0x2f, 0xb3, 0x70, 0xa4, 0xa1, 0x68, 0xdb,
	0x2b, 0x06, 0x26, 0x1e, 0x34, 0xaf, 0xf5, 0xd9, 0x43, 0x2d, 0xd7, 0x33, 0x01, 0xcb, 0x75, 0xee,
	0x3d, 0x6e, 0xa0, 0xca, 0x10, 0x79, 0xba, 0x07, 0x8e, 0xa8, 0x7e, 0x21, 0xaa, 0xc0, 0x40, 0x43,
	0x0a, 0x8c, 0x40, 0x35, 0x52, 0xb0, 0x38, 0xa7, 0xe9, 0x4a, 0x38, 0x15, 0xe9, 0x33, 0xf6, 0x87,
	0x02, 0x80, 0xe3, 0xa0, 0x97, 0xec, 0x60, 0x1f, 0xcf, 0x44, 0x30, 0x96, 0x75, 0x84, 0x9c, 0x1d,
	0x76, 0x84, 0x7c, 0x37, 0xe4, 0xec, 0x2e, 0x51, 0x7f, 0xcb, 0xbc, 0x4e, 0x90, 0xc9, 0x3b, 0xf6,
	0x34, 0xdf, 0x53, 0x4c, 0x79, 0x5d, 0xc5, 0x35, 0xad, 0x6b, 0xec, 0xf9, 0x6e, 0x0b, 0x66, 0xa4,
	0xfd, 0x0f, 0xfc, 0x18, 0x84, 0x79, 0x8e, 0x18, 0x84, 0xa4, 0x29, 0x26, 0x06, 0x21, 0x13, 0x38,
	0x27, 0x72, 0x41, 0xf4, 0x39, 0x13, 0x22, 0x1e, 0x22, 0xe4, 0xb6, 0x64, 0xd3, 0x65, 0x06, 0xf9,
	0x8f, 0xde, 0xc2, 0x35, 0xb9, 0x87, 0x56, 0x9d, 0x3e, 0xe6, 0xdf, 0xcc, 0xc2, 0x51, 0x37, 0xe6,
	0x3c, 0x41, 0xfd, 0x36, 0xe6, 0x6c, 0x84, 0x74, 0x28, 0xe3, 0x77, 0xc8, 0xce, 0xeb, 0xfb, 0x88,
	0x93, 0xff, 0xe8, 0x4d, 0xdc, 0xdf, 0x25, 0xc1, 0x96, 0x42, 0xb8, 0x18, 0x29, 0x57, 0x01, 0xef,
	0x60, 0x51, 0x5f, 0x23, 0x11, 0xcd, 0xc4, 0xe3, 0x68, 0xe5, 0xc0, 0xd7, 0x7e, 0xd0, 0xff, 0x2c,
	0x02, 0x34, 0xe5, 0x5d, 0x65, 0xd3, 0xf1, 0xb2, 0xf4, 0x55, 0xc1, 0x9e, 0xbc, 0x4c, 0xcb, 0x89,
	0x96, 0x60, 0x32, 0xce, 0x16, 0xef, 0x82, 0x22, 0xb5, 0xa7, 0xa3, 0xbd, 0x7a, 0x32, 0xd3, 0x2b,
	0xbf, 0x16, 0x47, 0x9e, 0x1f, 0xb2, 0x24, 0xb7, 0xbc, 0xbd, 0x01, 0xd9, 0x18, 0xa8, 0x6a, 0xc7,
	0x7e, 0x97, 0xaa, 0x70, 0xdd, 0xb4, 0xef, 0x34, 0x93, 0x86, 0x33, 0x22, 0x89, 0x21, 0x17, 0x9b,
	0x79, 0xd7, 0xc5, 0x26, 0xfa, 0x03, 0xee, 0xe8, 0x8f, 0x01, 0x7a, 0x02, 0x3d, 0x0a, 0x81, 0xf5,
	0x76, 0x28, 0x3a, 0x66, 0x32, 0xee, 0xdd, 0xff, 0x27, 0x0e, 0x0d, 0x54, 0xe7, 0xf5, 0xba, 0xb6,
	0xa1, 0x4b, 0x6e, 0x49, 0xce, 0x20, 0x90, 0x5c, 0x74, 0xa4, 0x3f, 0x92, 0xbe, 0x2c, 0xc0, 0xc9,
	0x73, 0xd8, 0xf2, 0xfb, 0x71, 0x49, 0xb1, 0xb6, 0xec, 0xe9, 0xdc, 0x44, 0xff, 0x92, 0xcf, 0x7c,
	0x28, 0x80, 0x7f, 0x36, 0x1e, 0xfe, 0xe8, 0xcf, 0x82, 0xa8, 0xb5, 0x59, 0xd4, 0xee, 0x0d, 0xab,
	0x65, 0x34, 0xb5, 0x21, 0x00, 0xde, 0x0d, 0x05, 0x87, 0x50, 0xba, 0xee, 0x9d, 0x0e, 0xc5, 0xcf,
	0xab, 0x49, 0xa2, 0x6f, 0xa0, 0x8f, 0x7a, 0x38, 0x5e, 0x64, 0x70, 0x5c, 0x38, 0x10, 0x65, 0xa9,
	0x43, 0x7a, 0xfa, 0x36, 0x62, 0x9c, 0x40, 0x06, 0xd8, 0xb1, 0xe0, 0x28, 0x2e, 0x5d, 0x25, 0x02,
	0x14, 0x96, 0xf5, 0x5d, 0xdc, 0xd1, 0x4b, 0x19, 0xfb, 0xbf, 0x4d, 0x5f, 0x47, 0x2f, 0x65, 0xd1,
	0xbf, 0x39, 0x02, 0xc5, 0xf3, 0x8a, 0x69, 0xe9, 0xc6, 0x1e, 0xfa, 0x52, 0x0e, 0x66, 0xa8, 0xf6,
	0xca, 0x44, 0xef, 0xca, 0x78, 0xba, 0xb8, 0x7d, 0x4a, 0xa0, 0xeb, 0xe1, 0x48, 0xdf, 0x5e, 0xf3,
	0xf5, 0x81, 0xe9, 0x5b, 0x20, 0x06, 0xb3, 0x6c, 0xb1, 0x91, 0x07, 0xd6, 0x96, 0x6e, 0xf8, 0xb6,
	0xe0, 0x6e, 0xda, 0xfe, 0xc0, 0x70, 0xfe, 0x37, 0xe5, 0x1d, 0xec, 0xba, 0x77, 0xf4, 0x73, 0x48,
	0x0c, 0x6c, 0x65, 0xc7, 0x59, 0x20, 0x05, 0x89, 0xfc, 0x17, 0xe7, 0xa1, 0xb8, 0x69, 0xe8, 0x83,
	0x3e, 0xfd, 0x1c, 0x12, 0x24, 0x37, 0x19, 0xf4, 0x26, 0x7a, 0x12, 0x0a, 0x7d, 0x79, 0xd3, 0xb7,
	0xc0, 0xa2, 0x29, 0xf1, 0x06, 0x98, 0x53, 0x65, 0xd3, 0xa2, 0xbd, 0xf1, 0xbe, 0xfd, 0xd8, 0xcc,
	0xd1, 0xd3, 0x0e, 0xfa, 0x18, 0xb7, 0x4a, 0x84, 0x72, 0xd1, 0xd5, 0xff, 0x85, 0xc9, 0x65, 0x05,
	0x66, 0xa8, 0xa6, 0xd1, 0x9d, 0x59, 0x6e, 0x8c, 0xae, 0x86, 0xfe, 0x91, 0xbc, 0xd7, 0x38, 0x6d,
	0xbf, 0xc6, 0xd0, 0x93, 0xfe, 0x04, 0xf3, 0xdf, 0xdc, 0xfb, 0xbc, 0x0f, 0x8e, 0x87, 0xe8, 0x3a,
	0x98, 0xdd, 0x1d, 0x82, 0xc7, 0xcf, 0x88, 0xb8, 0xcd, 0xfb, 0x4b, 0x02, 0xef, 0x52, 0xee, 0xb2,
	0x23, 0xe2, 0x3e, 0xef, 0xdd, 0x00, 0xce, 0x04, 0x60, 0x97, 0xd9, 0xb7, 0x5d, 0x26, 0xdf, 0x7b,
	0x74, 0xda, 0x20, 0xb5, 0x48, 0x81, 0xd2, 0xe2, 0xfd, 0xbe, 0x3e, 0xd9, 0x39, 0xf7, 0xe3, 0x44,
	0x35, 0xa8, 0x76, 0x76, 0xfb, 0x98, 0x63, 0xfb, 0xc8, 0x67, 0x7f, 0x1f, 0xd1, 0xbf, 0xf4, 0xa1,
	0xfe, 0x42, 0x16, 0xa0, 0x8d, 0xdd, 0xc1, 0x14, 0xb4, 0x8c, 0x9a, 0x08, 0x70, 0xf4, 0xe3, 0x0c,
	0x6f, 0x68, 0x2f, 0xaf, 0xdb, 0x5e, 0xeb, 0x61, 0x36, 0x00, 0x5c, 0xc1, 0xba, 0xc6, 0x56, 0x97,
	0x3e, 0x2f, 0x5f, 0x26, 0x40, 0x8e, 0x5c, 0x7a, 0xfb, 0x07, 0xdf, 0x60, 0xf2, 0x1e, 0x9f, 0xa1,
	0x81, 0xdb, 0x43, 0x19, 0xbe, 0xdb, 0x43, 0xe8, 0x11, 0xee, 0x6f, 0x4a, 0x72, 0xf7, 0x2a, 0xd2,
	0x78, 0xc7, 0xc7, 0x53, 0x60, 0xf0, 0x8c, 0x77, 0xc1, 0x87, 0xef, 0xdb, 0x32, 0x9c, 0x9a, 0xf4,
	0x51, 0xf8, 0x13, 0x1a, 0x23, 0xed, 0xb3, 0xfe, 0xc5, 0x53, 0x8b, 0x91, 0x6a, 0x7a, 0xb5, 0x2b,
	0x13, 0x76, 0xb5, 0x2b, 0x3b, 0xd1, 0xed, 0x43, 0x61, 0x9f, 0xb3, 0xe3, 0xc7, 0xb8, 0xfd, 0x15,
	0xb4, 0xc7, 0x59, 0xc0, 0x3a, 0xcb, 0xb8, 0xe0, 0x2d, 0xe3, 0xf1, 0x30, 0xfb, 0x24, 0xd7, 0xa7,
	0x61, 0x3b, 0x19, 0x03, 0xd9, 0xc4, 0xef, 0x63, 0xbd, 0xe1, 0x04, 0x13, 0x02, 0xef, 0xb1, 0x2c,
	0xe4, 0xc8, 0x79, 0x4a, 0x40, 0xd7, 0xfc, 0x21, 0xee, 0x9b, 0x72, 0x81, 0xd0, 0x71, 0xe4, 0x9c,
	0x61, 0x34, 0xbb, 0x9f, 0x0b, 0x47, 0xfc, 0x00, 0x79, 0xd1, 0x9f, 0x11, 0x44, 0x9b, 0x10, 0x2c,
	0xcd, 0xe9, 0xd3, 0x28, 0x9a, 0x90, 0xf4, 0x47, 0xc9, 0xdb, 0xfc, 0xd1, 0xb1, 0x18, 0xfc, 0x2e,
	0x04, 0xbf, 0x2b, 0x94, 0x81, 0x11, 0xfd, 0x0e, 0x14, 0x46, 0x7f, 0x1a, 0xc4, 0xa0, 0xca, 0x62,
	0xf0, 0x8c, 0xb0, 0xae, 0x47, 0x0a, 0x3d, 0x4b, 0x4c, 0x36, 0x0e, 0x31, 0xbe, 0x55, 0xf8, 0x12,
	0x83, 0xc1, 0xd9, 0x58, 0x84, 0x1c, 0xb2, 0xe0, 0xbf, 0xf5, 0x58, 0x20, 0x84, 0xea, 0xb7, 0x69,
	0xc8, 0xce, 0x0d, 0xc6, 0x7f, 0x01, 0x1b, 0xdb, 0x31, 0x33, 0x22, 0xb6, 0xe3, 0xa4, 0xce, 0xf0,
	0x7e, 0x18, 0x84, 0xb3, 0xce, 0xc2, 0x79, 0x7b, 0x18, 0x17, 0x39, 0xe2, 0x74, 0x4e, 0x48, 0xce,
	0xe3, 0x1e, 0xa0, 0x0d, 0x06, 0xd0, 0x3b, 0x27, 0x20, 0x25, 0x1e, 0xac, 0x4a, 0xc2, 0xb0, 0x8a,
	0xf3, 0x70, 0x42, 0xaa, 0x55, 0x16, 0x5b, 0xcd, 0xc6, 0x83, 0xc1, 0xa7, 0xa5, 0x1c, 0x7a, 0x8b,
	0x00, 0x05, 0x89, 0x98, 0x17, 0xa1, 0x9f, 0x8b, 0x0b, 0xf3, 0x90, 0x9f, 0xcd, 0xec, 0x7e, 0xef,
	0xcd, 0x9f, 0xe1, 0xbe, 0x0c, 0x34, 0x8a, 0x8d, 0x0e, 0x5d, 0x21, 0x3b, 0xb4, 0xef, 0x72, 0x5d,
	0x06, 0xe2, 0xae, 0xf6, 0x8a, 0x05, 0xe8, 0x11, 0x01, 0x0a, 0xd4, 0x99, 0x6e, 0x2f, 0x2e, 0x40,
	0x41, 0x4f, 0xe9, 0x59, 0x5e, 0x4f, 0xe9, 0x07, 0xc3, 0x2c, 0x32, 0x1c, 0xc9, 0xe4, 0x98, 0x25,
	0xe0, 0xac, 0x76, 0x8a, 0x98, 0x7d, 0x4d, 0xa0, 0xfb, 0x85, 0x41, 0x5c, 0xc4, 0x16, 0xe1, 0x49,
	0x72, 0xbf, 0x8f, 0x35, 0xcf, 0x2d, 0xab, 0xb9, 0x64, 0xe8, 0x3b, 0x2d, 0x6b, 0x0b, 0x1b, 0xee,
	0xbe, 0x20, 0x73, 0xf3, 0x8c, 0x14, 0x5d, 0x88, 0xf5, 0xfd, 0x10, 0xe9, 0x17, 0x73, 0x14, 0xaf,
	0x23, 0x36, 0x29, 0x13, 0xce, 0xa4, 0x5f, 0xe0, 0x72, 0x90, 0xc9, 0x49, 0xcb, 0x21, 0xaf, 0x90,
	0xaf, 0x68, 0x40, 0xc1, 0xa1, 0xd4, 0xde, 0x16, 0x1e, 0x69, 0x6f, 0xc9, 0x06, 0x5e, 0xd8, 0x23,
	0x81, 0xe3, 0x6f, 0xe4, 0x52, 0x84, 0xa2, 0x57, 0x07, 0xd1, 0x11, 0x21, 0xa7, 0x2a, 0xda, 0xb6,
	0x7b, 0x0a, 0x61, 0xff, 0xf7, 0x3f, 0x61, 0xb3, 0x23, 0x3e, 0x61, 0x3d, 0x95, 0x82, 0xd7, 0xee,
	0x81, 0x3e, 0x61, 0xc7, 0x56, 0x37, 0x95, 0x13, 0xcf, 0xe3, 0x95, 0x5e, 0xef, 0x92, 0x62, 0x6d,
	0xb5, 0x5c, 0x1e, 0xdd, 0xcf, 0xa7, 0x53, 0x9e, 0x87, 0x62, 0x5f, 0xde, 0x53, 0x75, 0xd9, 0xbb,
	0x96, 0x4f, 0x93, 0xac, 0x81, 0x64, 0xa4, 0xa2, 0x9f, 0x72, 0x60, 0x88, 0x82, 0x10, 0xa6, 0xf2,
	0xe9, 0xec, 0xb9, 0xaa, 0x4c, 0x9f, 0xb1, 0xbf, 0x38, 0x14, 0xba, 0xe5, 0xe7, 0x79, 0xbd, 0x1d,
	0x4c, 0xb4, 0x6e, 0xbc, 0x4e, 0xe0, 0xd5, 0xc2, 0x50, 0xf6, 0xfc, 0x94, 0x04, 0x66, 0xf9, 0x44,
	0x9c, 0x71, 0x94, 0x54, 0x40, 0x96, 0xa5, 0x09, 0xa6, 0x2d, 0x11, 0x8e, 0x55, 0x1a, 0xf6, 0x8a,
	0xf4, 0x20, 0x35, 0x75, 0x2f, 0x01, 0xfa, 0xcc, 0xfe, 0x20, 0x2d, 0xff, 0x8a, 0x57, 0x0a, 0xc6,
	0x6e, 0xef, 0x26, 0x0b, 0xe4, 0xf3, 0x7e, 0x6e, 0x57, 0x73, 0x43, 0x3c, 0x4d, 0xd0, 0x89, 0x3e,
	0x9f, 0x43, 0x39, 0x9e, 0xf6, 0xd3, 0x1f, 0xc5, 0xaf, 0xda, 0x1f, 0x79, 0xa5, 0x9e, 0x18, 0x84,
	0x93, 0xa3, 0x91, 0x60, 0x5c, 0x95, 0x89, 0xd0, 0x38, 0x24, 0x4f, 0xf5, 0x2f, 0xcf, 0xc1, 0xd5,
	0xfb, 0x23, 0xa9, 0xf0, 0x47, 0x59, 0x1e, 0x3f, 0xa8, 0x26, 0x0d, 0x23, 0xf2, 0xbd, 0x98, 0x9b,
	0xbe, 0xf2, 0x95, 0x15, 0x05, 0xe5, 0x7d, 0x31, 0xf6, 0x88, 0xe5, 0xc3, 0x8f, 0x7b, 0xf2, 0x97,
	0x02, 0x9c, 0x18, 0x19, 0xf1, 0xe4, 0x4a, 0x10, 0x05, 0xfe, 0xa0, 0x86, 0x23, 0xf9, 0x99, 0xe0,
	0x44, 0xcb, 0x17, 0xef, 0x8e, 0x9f, 0x8a, 0xf4, 0x81, 0xfd, 0x44, 0x6e, 0x18, 0x58, 0x3a, 0xe9,
	0x7e, 0x30, 0x41, 0x60, 0x83, 0xf1, 0x47, 0x84, 0xa1, 0xf8, 0x23, 0xe7, 0xe1, 0xc9, 0xe4, 0x9e,
	0x9f, 0xb1, 0xe3, 0x28, 0x2a, 0x2a, 0xaa, 0x7a, 0x51, 0x56, 0x07, 0xd8, 0xac, 0x6b, 0x4e, 0xc4,
	0x0e, 0xf7, 0xbe, 0xf8, 0xb8, 0x62, 0xe8, 0x07, 0x07, 0x13, 0x83, 0x04, 0xe3, 0x93, 0x7c, 0x77,
	0x72, 0x31, 0x48, 0x60, 0x9e, 0xdf, 0x9a, 0x60, 0x33, 0xf5, 0x2c, 0x78, 0x66, 0xbb, 0xb5, 0x5c,
	0x23, 0xf7, 0xfc, 0xa4, 0xc5, 0xf6, 0xda, 0xf9, 0x4a, 0x7b, 0x4d, 0xaa, 0x35, 0x2a, 0xe4, 0x96,
	0xf2, 0xc5, 0x4a, 0x63, 0xb5, 0xb6, 0x76, 0xa9, 0xde, 0x39, 0xbf, 0xd6, 0x39, 0x5f, 0x6f, 0xaf,
	0xb5, 0x56, 0xec, 0xec, 0x92, 0x80, 0x1e, 0x0e, 0x8d, 0x63, 0xc2, 0xed, 0xed, 0xfd, 0x31, 0xee,
	0x70, 0xbf, 0x43, 0xec, 0x4a, 0x31, 0x4a, 0x09, 0x5f, 0xdc, 0xdf, 0x18, 0xf4, 0x4c, 0xe1, 0x44,
	0x2e, 0x07, 0x85, 0x36, 0x96, 0x8d, 0xee, 0x16, 0xfa, 0xad, 0x80, 0x3b, 0xd0, 0x25, 0x28, 0x6e,
	0x28, 0x2a, 0xf1, 0x68, 0x9f, 0x21, 0xdd, 0xbf, 0x95, 0x2f, 0xa4, 0xfd, 0x12, 0x79, 0x49, 0x72,
	0x5f, 0x16, 0x9f, 0x07, 0x79, 0x53, 0x37, 0x3c, 0x73, 0x2f, 0xce, 0xc0, 0xf8, 0x6d, 0xdd, 0xb0,
	0x24, 0xe7, 0x45, 0xc6, 0xa6, 0x4d, 0x18, 0xb2, 0x69, 0x0b, 0xb1, 0x5e, 0x63, 0x03, 0x44, 0x7b,
	0xb6, 0x6e, 0xb7, 0x40, 0xc9, 0x57, 0x22, 0x39, 0x84, 0xce, 0x17, 0xc8, 0x41, 0xe3, 0xbe, 0x7c,
	0x51, 0x84, 0xdc, 0x36, 0xde, 0x33, 0xe7, 0x8b, 0xe4, 0x39, 0xf9, 0x8f, 0xde, 0xc1, 0xed, 0x38,
	0xc7, 0x55, 0x16, 0x10, 0xbe, 0x86, 0x88, 0xd8, 0x6d, 0x50, 0x34, 0xe8, 0x34, 0xe5, 0x0a, 0x58,
	0xd8, 0xa1, 0x26, 0x2d, 0x87, 0xde, 0xce, 0xe5, 0x4f, 0x27, 0xaa, 0xf1, 0x29, 0xf8, 0x14, 0x99,
	0x81, 0xfc, 0x39, 0x43, 0xee, 0x6f, 0xa1, 0x5f, 0xcb, 0x24, 0x2f, 0x4e, 0x1e, 0xb0, 0xd9, 0x71,
	0xc0, 0x0a, 0xa3, 0x81, 0x45, 0xaf, 0xcc, 0x42, 0xae, 0x69, 0x77, 0x6a, 0xd8, 0xfa, 0x4a, 0xa4,
	0xb6, 0xca, 0xd4, 0xa4, 0x95, 0xd8, 0x20, 0xbb, 0x6e, 0x41, 0x84, 0x80, 0x5b, 0x90, 0x93, 0x50,
	0x50, 0xe5, 0x3d, 0x7d, 0xe0, 0xc9, 0x9c, 0x93, 0x1a, 0x66, 0x67, 0x7e, 0x1f, 0x3b, 0xed, 0xf9,
	0x4c, 0xe9, 0xea, 0x5a, 0x7d, 0x47, 0xde, 0xc4, 0xf4, 0xfa, 0x89, 0x9f, 0xe1, 0x3e, 0xad, 0xed,
	0xe8, 0x2f, 0x54, 0xe8, 0x35, 0x13, 0x3f, 0xc3, 0xa6, 0xa4, 0xa7, 0x6b, 0x98, 0x5c, 0x2b, 0x99,
	0x91, 0xc8, 0x7f, 0xf1, 0x26, 0x38, 0xe6, 0x4e, 0x3d, 0x4b, 0xba, 0xb1, 0x23, 0x5b, 0xf3, 0xb3,
	0xce, 0x35, 0x30, 0x36, 0x57, 0x9c, 0x87, 0xa2, 0xa9, 0x29, 0xfd, 0x3e, 0xb6, 0xe6, 0xc1, 0x51,
	0xfe, 0xd0, 0x24, 0x7a, 0x63, 0x16, 0x72, 0xb5, 0xde, 0x26, 0x66, 0x4e, 0xde, 0x33, 0x81, 0x93,
	0xf7, 0x93, 0x50, 0x70, 0x9c, 0x8d, 0x52, 0xb6, 0xd0, 0xd4, 0x48, 0xc6, 0x3c, 0x87, 0x32, 0x30,
	0x37, 0xe2, 0xc2, 0x2f, 0x95, 0x49, 0x22, 0x18, 0x65, 0xbb, 0xc5, 0xa0, 0xa5, 0x77, 0xba, 0x9c,
	0x3b, 0x09, 0x85, 0x2d, 0xa5, 0xd7, 0xc3, 0x1a, 0xe5, 0x1d, 0x4d, 0x9d, 0x3e, 0x05, 0x39, 0x9b,
	0x06, 0x5b, 0xb8, 0x1b, 0x8a, 0xb6, 0x5d, 0xba, 0x4a, 0x3c, 0xea, 0x1f, 0xe9, 0x95, 0x32, 0xac,
	0x6e, 0x38, 0xd2, 0x06, 0x8a, 0xe9, 0xdc, 0xe8, 0xc1, 0xfe, 0x2c, 0xc8, 0x6b, 0x7a, 0xcf, 0x3b,
	0xae, 0x3e, 0x15, 0xfe, 0xbe, 0x2d, 0x9b, 0x92, 0x53, 0xd8, 0x7e, 0x0b, 0xf7, 0x36, 0xb1, 0x49,
	0x84, 0x39, 0xf2, 0x2d, 0x9b, 0xa5, 0x92, 0x53, 0x98, 0xd3, 0xb0, 0x29, 0x82, 0xe8, 0xf4, 0x27,
	0x89, 0xff, 0x5b, 0x80, 0xe3, 0xce, 0xfc, 0xd4, 0x1e, 0xac, 0xdb, 0x55, 0xad, 0x63, 0xf4, 0x5a,
	0x81, 0xb9, 0x41, 0x64, 0x0e, 0xd6, 0xbd, 0x55, 0xdf, 0x49, 0x04, 0x27, 0x91, 0x6c, 0x22, 0x6b,
	0x92, 0x30, 0xe9, 0x9a, 0xc4, 0xac, 0x2f, 0xc2, 0x7e, 0x5b, 0x6a, 0xc7, 0x98, 0xd2, 0x5d, 0x8d,
	0x46, 0xac, 0x25, 0xf6, 0x98, 0x94, 0x37, 0x2c, 0x6c, 0x78, 0x37, 0xc5, 0xdc, 0x24, 0x71, 0x57,
	0x8b, 0x37, 0x74, 0x03, 0xd7, 0x7b, 0x64, 0x3c, 0xcf, 0x4a, 0x5e, 0x3a, 0x30, 0x4c, 0x81, 0x31,
	0x90, 0xb9, 0x19, 0x8e, 0x2b, 0x9b, 0x9a, 0x6e, 0x60, 0xcf, 0x33, 0xdd, 0xfc, 0x51, 0xc7, 0xfd,
	0xd0, 0x50, 0xb6, 0x78, 0x2b, 0x5c, 0xad, 0xe9, 0x8b, 0xb8, 0x4f, 0xf9, 0xee, 0xa0, 0x3a, 0xe7,
	0xdc, 0xaa, 0xd8, 0xf7, 0x00, 0x7d, 0x59, 0x88, 0xa9, 0x1c, 0x1e, 0x02, 0x35, 0xb1, 0xa5, 0x4f,
	0x7c, 0x2e, 0x1c, 0xed, 0xe1, 0x3e, 0xd6, 0x7a, 0x58, 0xeb, 0x2a, 0xde, 0x88, 0x08, 0x7d, 0x8f,
	0x29, 0xec, 0x8b, 0x53, 0x2e, 0x28, 0x4e, 0xe7, 0x02, 0x51, 0x7b, 0xf2, 0x43, 0xe6, 0x28, 0xac,
	0x55, 0x62, 0x80, 0x25, 0x65, 0x1a, 0xbd, 0xc7, 0x0c, 0x84, 0xef, 0x89, 0xa5, 0xeb, 0x8e, 0xe6,
	0xd0, 0x14, 0xec, 0xe0, 0x72, 0x70, 0xb4, 0xde, 0x33, 0xfd, 0x71, 0xa7, 0x8f, 0x1b, 0x76, 0xfb,
	0x82, 0x2c, 0x78, 0x02, 0x2d, 0x04, 0x04, 0x7a, 0x84, 0x08, 0x1e, 0x19, 0x29, 0x82, 0xe8, 0x25,
	0x41, 0xa1, 0xaa, 0xb1, 0x42, 0x75, 0x66, 0x14, 0xcb, 0x82, 0xe4, 0x5e, 0xc9, 0x12, 0x85, 0xde,
	0xed, 0x09, 0xc2, 0x79, 0x46, 0x10, 0x9e, 0x15, 0xb3, 0x57, 0xe9, 0x4b, 0xc1, 0xbf, 0xcf, 0xc2,
	0xd5, 0x8e, 0x24, 0xae, 0x6a, 0xa6, 0x27, 0x0a, 0x4f, 0x61, 0x4d, 0xf1, 0xec, 0x3e, 0x99, 0x9e,
	0x29, 0x1e, 0x49, 0xa1, 0x97, 0xc7, 0x55, 0x9e, 0xed, 0x6b, 0x25, 0xe4, 0xc0, 0x28, 0x96, 0x5a,
	0x6b, 0x5c, 0xa5, 0xe9, 0x33, 0xf0, 0xd7, 0x9d, 0xd0, 0x8d, 0x0d, 0xb2, 0xf7, 0x43, 0x32, 0xaf,
	0xc6, 0xe3, 0x4e, 0x6f, 0xf3, 0xe8, 0x5c, 0x89, 0xbb, 0x3e, 0xd4, 0x64, 0xaa, 0xec, 0x54, 0xed,
	0x6e, 0x2f, 0xd1, 0x3b, 0xb9, 0x2d, 0xe6, 0x3d, 0x1e, 0x51, 0xea, 0x12, 0x51, 0x4c, 0xf0, 0x19,
	0xc7, 0x8f, 0x69, 0x3a, 0x7d, 0x58, 0x7e, 0x59, 0x80, 0x39, 0xe2, 0xcd, 0x76, 0x49, 0xde, 0xd5,
	0x0d, 0xc5, 0xc2, 0xe8, 0x1c, 0x2f, 0x34, 0xa7, 0x00, 0x14, 0xef, 0x35, 0x6a, 0x3e, 0x10, 0xc8,
	0x89, 0x11, 0x59, 0xc6, 0xe7, 0x82, 0x4f, 0xc7, 0x14, 0x23, 0xcb, 0x70, 0x34, 0x3f, 0x45, 0x20,
	0x2a, 0xce, 0x25, 0xff, 0x5e, 0x4c, 0x20, 0xdc, 0xd7, 0x7c, 0x20, 0xbc, 0x8a, 0x26, 0x03, 0xc2,
	0x7d, 0xfd, 0x90, 0x80, 0x08, 0x69, 0x3e, 0x7d, 0x20, 0x1e, 0x29, 0x40, 0x69, 0x09, 0xcb, 0xd6,
	0xc0, 0xc0, 0x9e, 0x19, 0x0c, 0xfa, 0x15, 0x6a, 0xb0, 0x58, 0xe3, 0xc5, 0xe4, 0xba, 0x61, 0x7d,
	0xd8, 0x6c, 0x50, 0xed, 0x15, 0x5b, 0x8d, 0x3e, 0x4c, 0x50, 0x39, 0xa1, 0x43, 0x95, 0x78, 0x6a,
	0x74, 0x0e, 0x2a, 0xd2, 0xc7, 0xe7, 0xb5, 0xbe, 0x5d, 0x61, 0x42, 0x68, 0x7c, 0x3a, 0x88, 0xc6,
	0x0a, 0x8b, 0xc6, 0xdd, 0x5c, 0x7c, 0x88, 0xb2, 0x27, 0x8c, 0x09, 0x88, 0xef, 0x3c, 0xa5, 0xcd,
	0x00, 0x72, 0xff, 0xe4, 0x84, 0x4c, 0x21, 0x6c, 0x4d, 0x16, 0xf2, 0x1d, 0xbd, 0x8d, 0x19, 0x67,
	0xc4, 0xd1, 0x90, 0xf8, 0x5f, 0x66, 0x59, 0x26, 0xf2, 0xf2, 0xcb, 0xe2, 0x6a, 0x11, 0x48, 0xbb,
	0xe1, 0x9e, 0x2c, 0xcc, 0x40, 0x4c, 0x1c, 0x27, 0x11, 0xef, 0x7b, 0x7f, 0x54, 0xf5, 0xe9, 0x33,
	0xf4, 0x23, 0x33, 0xee, 0x35, 0x01, 0x62, 0xed, 0xf7, 0xb5, 0x2c, 0x14, 0xe8, 0x61, 0x11, 0xab,
	0xee, 0x77, 0xed, 0x95, 0xdc, 0x5d, 0xa7, 0x9f, 0x81, 0xde, 0x15, 0xd3, 0x84, 0x9d, 0x18, 0xc4,
	0x25, 0x78, 0x32, 0xf3, 0xae, 0x18, 0x56, 0xeb, 0xe1, 0x6d, 0x4f, 0xe1, 0xce, 0x58, 0xde, 0xb9,
	0x61, 0xf3, 0x5f, 0xb2, 0x00, 0xa1, 0xab, 0x6f, 0x38, 0x9f, 0xc7, 0xae, 0xbe, 0x0f, 0x07, 0x71,
	0xb8, 0xc0, 0xe2, 0x70, 0x47, 0x18, 0x2f, 0x6c, 0x99, 0x1b, 0xb7, 0x04, 0xa3, 0xf7, 0x7b, 0x1c,
	0x6e, 0x32, 0x1c, 0xbe, 0x7b, 0xa2, 0x5a, 0xd3, 0xe7, 0xb4, 0xc3, 0xe1, 0x90, 0x8d, 0xe6, 0x38,
	0x0e, 0x47, 0x6c, 0x34, 0x0f, 0xc0, 0xe1, 0xe8, 0xdd, 0xe6, 0xa4, 0x1c, 0x3e, 0xb4, 0x4d, 0xe4,
	0xe3, 0x39, 0x28, 0xd4, 0x1e, 0xea, 0xeb, 0x86, 0x85, 0x3e, 0x9b, 0x61, 0x1c, 0x52, 0xf4, 0x7d,
	0xb7, 0xfb, 0xe4, 0xbf, 0x3d, 0xff, 0xf6, 0xf4, 0xae, 0x7f, 0x6d, 0x9a, 0xa6, 0xc4, 0xb3, 0x50,
	0xd8, 0x70, 0x74, 0xe3, 0xce, 0x07, 0x17, 0x62, 0xba, 0xea, 0x54, 0x5e, 0x76, 0xf4, 0xe4, 0x12,
	0x2d, 0x29, 0x96, 0x40, 0x78, 0xb1, 0xd2, 0xa7, 0x87, 0xc7, 0xf6, 0x5f, 0x12, 0xd1, 0x83, 0x7a,
	0x75, 0xc3, 0xa6, 0x85, 0x1d, 0x77, 0x53, 0x33, 0x12, 0x9b, 0x29, 0x9e, 0x86, 0xa3, 0x34, 0x63,
	0x49, 0x51, 0xb1, 0x13, 0x80, 0x6e, 0x46, 0x62, 0xf2, 0xd0, 0xa7, 0x82, 0xe0, 0xde, 0xc9, 0x82,
	0x7b, 0x7a, 0x14, 0x6d, 0xa1, 0x4e, 0x46, 0x86, 0xfd, 0x6f, 0x10, 0x35, 0xff, 0xa0, 0xdb, 0xc5,
	0xb8, 0x47, 0x4f, 0x26, 0xdc, 0x64, 0x4c, 0x2b, 0xa3, 0x37, 0x79, 0x52, 0xf2, 0x5c, 0x46, 0x4a,
	0x9e, 0x36, 0x9e, 0xbc, 0xf4, 0xef, 0xe2, 0xaf, 0x40, 0x81, 0x9e, 0x6a, 0x1c, 0x85, 0x99, 0x65,
	0xd9, 0xd8, 0xee, 0xe9, 0x97, 0x35, 0x47, 0x77, 0xbf, 0x42, 0x35, 0x36, 0xa5, 0x8c, 0x5d, 0xe3,
	0x03, 0xed, 0x56, 0xb3, 0x94, 0x15, 0x8b, 0x20, 0x2c, 0xb6, 0x3a, 0x25, 0xc1, 0xfe, 0xd3, 0xbe,
	0x78, 0xae, 0x94, 0x13, 0x8f, 0x01, 0x9c, 0x93, 0x2a, 0x2b, 0xe7, 0xd7, 0x48, 0x89, 0x3c, 0x7a,
	0xa5, 0x00, 0xc7, 0x9d, 0xce, 0xf8, 0x2a, 0xaa, 0xfb, 0xa3, 0x85, 0x6d, 0x7c, 0x94, 0x9b, 0x8f,
	0x72, 0x5f, 0x7a, 0x1b, 0x6a, 0x3a, 0x06, 0xde, 0xf1, 0x50, 0xe5, 0xbb, 0xf9, 0x16, 0x4d, 0xcd,
	0x14, 0x2e, 0xb7, 0x67, 0x5d, 0x30, 0x5c, 0xb7, 0x6a, 0xe6, 0x50, 0x0c, 0xa3, 0x61, 0x30, 0x62,
	0xb3, 0xda, 0xab, 0xf8, 0x8a, 0x60, 0x75, 0x18, 0x35, 0x53, 0xb9, 0x10, 0x5d, 0x72, 0x68, 0x20,
	0x61, 0x0c, 0x4c, 0x4b, 0x37, 0x70, 0xd0, 0x3d, 0x78, 0x8c, 0x59, 0x16, 0x3d, 0xca, 0xad, 0x9c,
	0x1a, 0x6e, 0x31, 0x35, 0x10, 0xf8, 0x14, 0x56, 0x63, 0xc8, 0x49, 0x1f, 0x85, 0x47, 0xb3, 0x70,
	0x74, 0x59, 0xde, 0xf6, 0xbc, 0x08, 0xf2, 0xdb, 0xbf, 0x30, 0x2e, 0xab, 0x22, 0xbf, 0x2c, 0x82,
	0xf5, 0x47, 0xde, 0x61, 0xce, 0x7a, 0x0e, 0xe5, 0xf8, 0xbe, 0x29, 0x22, 0x2a, 0x4e, 0x9f, 0x73,
	0xdf, 0xc8, 0xc2, 0x7c, 0x90, 0x80, 0x85, 0xbd, 0xc0, 0x45, 0x64, 0xd6, 0x51, 0xf8, 0xd0, 0xb5,
	0xd9, 0x59, 0xe6, 0x3a, 0xea, 0x6f, 0x70, 0x6b, 0xb4, 0xc3, 0x5a, 0xe3, 0xe4, 0x29, 0x9f, 0x86,
	0x9b, 0xb3, 0x91, 0x29, 0xd8, 0xf7, 0x65, 0x61, 0xae, 0xaa, 0xea, 0xda, 0x04, 0xa2, 0xf9, 0x4f,
	0x19, 0x5e, 0x43, 0x19, 0xa6, 0x01, 0x4e, 0x3e, 0xf2, 0x59, 0xc1, 0x44, 0xd5, 0x9c, 0x3e, 0xf3,
	0x3e, 0x93, 0x85, 0xe3, 0x0e, 0x76, 0x8b, 0x83, 0xbe, 0xaa, 0x74, 0x63, 0xb1, 0xef, 0x65, 0x31,
	0x6f, 0xcc, 0x7b, 0x4d, 0x70, 0x32, 0x30, 0xce, 0x25, 0xf8, 0xb0, 0xba, 0xa7, 0x10, 0x1f, 0x3e,
	0x07, 0xc7, 0x56, 0x35, 0xb3, 0xaf, 0xca, 0xe6, 0x16, 0x35, 0x50, 0xbb, 0x83, 0x39, 0xaa, 0x7c,
	0xd1, 0x00, 0x1b, 0x7b, 0xee, 0x51, 0x25, 0x49, 0x8c, 0x36, 0x0f, 0x42, 0x8f, 0x0a, 0xbc, 0xde,
	0x31, 0xd9, 0xf6, 0x42, 0xd8, 0x79, 0x1e, 0x66, 0xfa, 0x4a, 0xd7, 0x1a, 0x18, 0x78, 0xbf, 0x1d,
	0x42, 0x54, 0x25, 0x2b, 0xce, 0x4b, 0x92, 0xf7, 0x36, 0x92, 0xa1, 0x48, 0x33, 0xf7, 0x59, 0x23,
	0x51, 0x4f, 0x8b, 0x59, 0xdf, 0xd3, 0xe2, 0x49, 0x28, 0xc8, 0x86, 0xa5, 0x98, 0xae, 0x15, 0x1c,
	0x4d, 0xd9, 0xb2, 0xe4, 0xfc, 0x5b, 0x35, 0x54, 0x7a, 0x1c, 0xe9, 0x67, 0x04, 0xdc, 0x4b, 0x44,
	0xb9, 0xf2, 0x8c, 0xec, 0x77, 0x3c, 0xa8, 0x2f, 0x4c, 0x60, 0x43, 0x7a, 0x0d, 0xfc, 0x8c, 0x44,
	0xa2, 0x5e, 0xd4, 0x97, 0xeb, 0x9d, 0xb5, 0xda, 0xf3, 0xab, 0xb5, 0xda, 0x62, 0x6d, 0xb1, 0xd4,
	0x43, 0xdf, 0xca, 0x42, 0xc9, 0xa5, 0xcd, 0xf5, 0xe6, 0x37, 0x34, 0x8e, 0x28, 0x33, 0xfd, 0x71,
	0xe4, 0x65, 0xb0, 0xf6, 0x7a, 0x91, 0xbb, 0x92, 0xe1, 0x36, 0x62, 0xb8, 0x76, 0xfc, 0x14, 0xd7,
	0x3e, 0x63, 0x4c, 0x03, 0x87, 0xc8, 0xe2, 0x2f, 0x66, 0x61, 0xae, 0xd2, 0xef, 0xab, 0x7b, 0xde,
	0x34, 0x1f, 0xe7, 0xa0, 0x26, 0xe0, 0x63, 0x25, 0xbb, 0xcf, 0xc7, 0xca, 0x0f, 0xb8, 0x97, 0x01,
	0x86, 0x80, 0x10, 0xe5, 0x05, 0xdf, 0xb4, 0x1f, 0x55, 0x53, 0xfa, 0x73, 0xd6, 0x6b, 0x7e, 0x06,
	0xf2, 0x24, 0xf2, 0x19, 0x7a, 0x8f, 0x00, 0x45, 0x55, 0xdf, 0xac, 0x6b, 0x1b, 0xfa, 0x28, 0x4b,
	0xc3, 0x2d, 0xec, 0xdd, 0xc4, 0x24, 0xff, 0xc5, 0x9b, 0xe0, 0x98, 0xfd, 0xeb, 0xca, 0x07, 0x75,
	0xd5, 0x3e, 0x23, 0x0d, 0xe5, 0x8a, 0xa7, 0xe1, 0xa8, 0xa5, 0x5b, 0xb2, 0x1a, 0xb4, 0x70, 0xcf,
	0x4b, 0x4c, 0x9e, 0x8d, 0x1a, 0x49, 0xb7, 0x95, 0x17, 0x63, 0x6a, 0x01, 0xeb, 0x67, 0x88, 0x37,
	0xc0, 0xdc, 0x86, 0x62, 0x98, 0x96, 0x53, 0xba, 0xe3, 0xa8, 0x29, 0xf2, 0x12, 0x9b, 0xe9, 0xb8,
	0x98, 0xf7, 0x32, 0x2e, 0x62, 0x83, 0x18, 0xd6, 0x11, 0x17, 0xf3, 0xc1, 0x5c, 0x9b, 0x1e, 0x55,
	0x0e, 0x54, 0x36, 0xe3, 0xd0, 0x13, 0xcc, 0x73, 0x1d, 0xc5, 0xf9, 0x55, 0x39, 0x66, 0x8a, 0x6c,
	0xa6, 0xdd, 0xa2, 0x9d, 0xb1, 0x32, 0x50, 0xd5, 0x36, 0xee, 0x56, 0x36, 0x75, 0x62, 0xac, 0x98,
	0x97, 0x86, 0x72, 0x45, 0x04, 0x33, 0x83, 0x7e, 0xdb, 0x92, 0xad, 0x81, 0x49, 0x2d, 0x4c, 0xbc,
	0xb4, 0x2d, 0x91, 0x3d, 0xfd, 0xb2, 0x46, 0x9f, 0x3a, 0x26, 0x50, 0x81, 0x1c, 0x7b, 0x7d, 0x70,
	0x84, 0x70, 0xce, 0x59, 0x35, 0x1c, 0xc9, 0xfa, 0x73, 0x01, 0xc0, 0xda, 0x32, 0xb0, 0xdc, 0x1b,
	0x09, 0xd7, 0xb3, 0xe1, 0xa4, 0xaa, 0x6f, 0x9a, 0x97, 0x14, 0x6b, 0xcb, 0x07, 0xe2, 0xbc, 0x0b,
	0x60, 0x5e, 0x0a, 0x79, 0x2a, 0x3e, 0x0f, 0xae, 0x75, 0x9f, 0x5c, 0xda, 0xd2, 0x55, 0xdc, 0x31,
	0x30, 0x1e, 0xc2, 0x37, 0x2f, 0x45, 0x15, 0x11, 0xcb, 0x90, 0xb3, 0x1f, 0xcf, 0xe7, 0xc8, 0x2a,
	0xc3, 0xaa, 0xae, 0x88, 0x98, 0x95, 0xa9, 0x88, 0x49, 0xa4, 0x9c, 0x78, 0x27, 0x5c, 0xa3, 0x5f,
	0xd6, 0x1a, 0xfa, 0xe6, 0x79, 0xd9, 0xac, 0xca, 0x1b, 0x58, 0xc2, 0xce, 0xe2, 0xad, 0x1b, 0x54,
	0x61, 0x15, 0xf6, 0x58, 0x2c, 0x83, 0xd8, 0x95, 0x37, 0x70, 0x83, 0x05, 0xc0, 0x91, 0x8c, 0x11,
	0x4f, 0x6c, 0xd8, 0xed, 0xdc, 0x55, 0x17, 0x08, 0xc7, 0xea, 0x92, 0xc9, 0xb3, 0x01, 0xb5, 0xd3,
	0x8b, 0x3e, 0x20, 0x8e, 0xa5, 0xdb, 0x50, 0xee, 0x3e, 0x91, 0x9e, 0x1d, 0x27, 0xd2, 0x30, 0x2c,
	0xd2, 0x1e, 0xac, 0x47, 0x82, 0xb0, 0x7e, 0x35, 0x0f, 0xb9, 0xf6, 0x9e, 0xd6, 0xb5, 0xf7, 0x3b,
	0xde, 0x8c, 0x76, 0x16, 0x4e, 0x50, 0x03, 0xa0, 0x8e, 0x21, 0xef, 0x62, 0xc3, 0xc4, 0x0d, 0xb2,
	0x61, 0x70, 0x5c, 0x95, 0x8f, 0x7c, 0x66, 0xcb, 0xaf, 0xb9, 0xad, 0xf4, 0x6b, 0x3b, 0x7d, 0x6b,
	0xaf, 0x61, 0xe3, 0x41, 0xe3, 0xf9, 0x32, 0x99, 0xe2, 0x7d, 0x80, 0x2c, 0x63, 0xaf, 0xa3, 0xbb,
	0xf8, 0x49, 0x78, 0x47, 0xb7, 0xb0, 0xdb, 0x29, 0x1a, 0xeb, 0x30, 0xbc, 0x04, 0xfa, 0x5d, 0x6e,
	0x9f, 0xfc, 0x0e, 0xf4, 0x76, 0xd7, 0x42, 0xd6, 0xa9, 0xe7, 0x40, 0xd1, 0x91, 0x67, 0x77, 0x83,
	0xf2, 0xa4, 0x11, 0xef, 0xfb, 0x12, 0x2f, 0xb9, 0xa5, 0x19, 0x07, 0xf6, 0xc2, 0x90, 0x03, 0x7b,
	0x17, 0xa6, 0x0e, 0xad, 0x39, 0x38, 0xf3, 0xd0, 0x3c, 0xc2, 0x03, 0xe7, 0xaf, 0x2d, 0xd2, 0xfa,
	0xc0, 0xb2, 0x45, 0xac, 0xae, 0xb5, 0x88, 0xd4, 0xd1, 0xa9, 0x28, 0xa2, 0x84, 0xb8, 0x00, 0xd7,
	0xb1, 0x4f, 0xcf, 0xb3, 0x73, 0xa2, 0x23, 0x90, 0x91, 0x65, 0xf6, 0x89, 0x53, 0x71, 0x9c, 0x38,
	0xcd, 0x0c, 0x89, 0x13, 0xa7, 0xb7, 0xe6, 0x50, 0x14, 0xd2, 0x5f, 0x66, 0x3e, 0x2e, 0x40, 0xc1,
	0x61, 0x39, 0x7a, 0x55, 0x86, 0x71, 0x00, 0x40, 0x41, 0xf5, 0x1c, 0x00, 0xb8, 0xe9, 0x29, 0xc9,
	0xf0, 0xdb, 0xf8, 0x5d, 0x40, 0x13, 0xee, 0x39, 0x9d, 0x08, 0xb5, 0xe9, 0xcb, 0x29, 0xda, 0x86,
	0x4e, 0x8f, 0xe7, 0xc6, 0x88, 0x30, 0x29, 0xca, 0xa9, 0xb6, 0x88, 0x68, 0x7b, 0x2a, 0x81, 0xc5,
	0x73, 0xf6, 0x34, 0x8f, 0x5e, 0xc0, 0x84, 0x99, 0x59, 0xa7, 0x21, 0x2f, 0x68, 0x14, 0x2d, 0x9a,
	0x1c, 0xa9, 0x07, 0x3b, 0x0d, 0x47, 0x07, 0x9a, 0xac, 0xe9, 0xda, 0xde, 0x8e, 0xf2, 0x62, 0x6f,
	0xa3, 0xc0, 0xe4, 0xb1, 0x66, 0x7a, 0x1c, 0x93, 0x89, 0x4d, 0x51, 0x78, 0x80, 0xe7, 0x0d, 0x45,
	0xc5, 0xc4, 0xdc, 0xdf, 0xf5, 0x29, 0x4d, 0xd3, 0xb1, 0x46, 0xca, 0x88, 0x26, 0xd2, 0xe7, 0xf6,
	0xdf, 0x67, 0xe0, 0xc4, 0x39, 0xac, 0x61, 0x43, 0xe9, 0x3a, 0x9d, 0xe2, 0xf2, 0xd7, 0x38, 0xea,
	0x0d, 0x76, 0x33, 0xca, 0xe7, 0x69, 0x31, 0xbc, 0x9e, 0xf4, 0x0f, 0x4a, 0x8a, 0x90, 0x27, 0xe3,
	0x7a, 0xe1, 0xba, 0xcf, 0x3f, 0x7e, 0x2a, 0xf3, 0xe5, 0xc7, 0x4f, 0x65, 0xbe, 0xf5, 0xf8, 0xa9,
	0xcc, 0xaf, 0x7e, 0xe7, 0xd4, 0x55, 0x5f, 0xfe, 0xce, 0xa9, 0xab, 0xfe, 0xea, 0x3b, 0xa7, 0xae,
	0xfa, 0x67, 0xd9, 0xfe, 0xfa, 0x7a, 0x81, 0xd8, 0xb9, 0xde, 0xfe, 0xff, 0x02, 0x00, 0x00, 0xff,
	0xff, 0x97, 0x28, 0x26, 0x8f, 0x75, 0x0e, 0x01, 0x00,
}

func (m *Rpc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Rpc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Rpc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcMetrics) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMetrics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcMetricsSetParameters) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMetricsSetParameters) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMetricsSetParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcMetricsSetParametersRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMetricsSetParametersRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMetricsSetParametersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Platform) > 0 {
		i -= len(m.Platform)
		copy(dAtA[i:], m.Platform)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Platform)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcMetricsSetParametersResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMetricsSetParametersResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMetricsSetParametersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcMetricsSetParametersResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMetricsSetParametersResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMetricsSetParametersResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcExternalDrop) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDrop) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDrop) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropFiles) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropFiles) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropFiles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropFilesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropFilesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropFilesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LocalFilePaths) > 0 {
		for iNdEx := len(m.LocalFilePaths) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.LocalFilePaths[iNdEx])
			copy(dAtA[i:], m.LocalFilePaths[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.LocalFilePaths[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DropTargetId) > 0 {
		i -= len(m.DropTargetId)
		copy(dAtA[i:], m.DropTargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DropTargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropFilesResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropFilesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropFilesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropFilesResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropFilesResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropFilesResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropContent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropContentRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropContentRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropContentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Content) > 0 {
		i -= len(m.Content)
		copy(dAtA[i:], m.Content)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Content)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FocusedBlockId) > 0 {
		i -= len(m.FocusedBlockId)
		copy(dAtA[i:], m.FocusedBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.FocusedBlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropContentResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropContentResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExternalDropContentResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExternalDropContentResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExternalDropContentResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListConvertChildrenToPages) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertChildrenToPages) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertChildrenToPages) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListConvertChildrenToPagesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertChildrenToPagesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertChildrenToPagesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectType) > 0 {
		i -= len(m.ObjectType)
		copy(dAtA[i:], m.ObjectType)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectType)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListConvertChildrenToPagesResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertChildrenToPagesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertChildrenToPagesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LinkIds) > 0 {
		for iNdEx := len(m.LinkIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.LinkIds[iNdEx])
			copy(dAtA[i:], m.LinkIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.LinkIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListConvertChildrenToPagesResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertChildrenToPagesResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertChildrenToPagesResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x28
	}
	if len(m.DropTargetId) > 0 {
		i -= len(m.DropTargetId)
		copy(dAtA[i:], m.DropTargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DropTargetId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.TargetContextId) > 0 {
		i -= len(m.TargetContextId)
		copy(dAtA[i:], m.TargetContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetContextId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveToNewPage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewPage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewPage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveToNewPageRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewPageRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewPageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x28
	}
	if len(m.DropTargetId) > 0 {
		i -= len(m.DropTargetId)
		copy(dAtA[i:], m.DropTargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DropTargetId)))
		i--
		dAtA[i] = 0x22
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveToNewPageResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewPageResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewPageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.LinkId) > 0 {
		i -= len(m.LinkId)
		copy(dAtA[i:], m.LinkId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.LinkId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveToNewPageResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewPageResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewPageResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListDuplicate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDuplicate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListDuplicateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDuplicateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDuplicateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x20
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListDuplicateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDuplicateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDuplicateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListDuplicateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDuplicateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDuplicateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextStyleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextStyleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextStyleResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextColor) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextColorRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextColorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextColorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextColorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextColorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextColorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextColorResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextColorResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextColorResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextMark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextMark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextMark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextMarkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextMarkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextMarkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mark != nil {
		{
			size, err := m.Mark.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextMarkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextMarkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextMarkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetTextMarkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetTextMarkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetTextMarkResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetBackgroundColor) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetBackgroundColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetBackgroundColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetBackgroundColorRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetBackgroundColorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetBackgroundColorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetBackgroundColorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetBackgroundColorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetBackgroundColorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetBackgroundColorResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetBackgroundColorResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetBackgroundColorResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetAlign) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetAlignRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetAlignRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetAlignRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Align != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Align))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetAlignResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetAlignResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetAlignResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetAlignResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetAlignResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetAlignResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFields) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFieldsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFieldsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFieldsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockFields) > 0 {
		for iNdEx := len(m.BlockFields) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockFields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFieldsRequestBlockField) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFieldsRequestBlockField) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFieldsRequestBlockField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFieldsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFieldsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFieldsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFieldsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFieldsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFieldsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetDiv) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetDivStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetDivStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetDivStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetDivStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetDivStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetDivStyleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetDivStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetDivStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetDivStyleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetDivStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetDivStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetDivStyleResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFileStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFileStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFileStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFileStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFileStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFileStyleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFileStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFileStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFileStyleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetFileStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetFileStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetFileStyleResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListTurnInto) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListTurnInto) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListTurnInto) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListTurnIntoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListTurnIntoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListTurnIntoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListTurnIntoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListTurnIntoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListTurnIntoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListTurnIntoResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListTurnIntoResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListTurnIntoResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlock) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockReplace) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockReplace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockReplace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockReplaceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockReplaceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockReplaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockReplaceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockReplaceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockReplaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockReplaceResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockReplaceResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockReplaceResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpdateContent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpdateContentRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateContentRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateContentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpdateContentResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateContentResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpdateContentResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateContentResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateContentResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSplit) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSplit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSplit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSplitRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSplitRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x28
	}
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x20
	}
	if m.Range != nil {
		{
			size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSplitResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSplitResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSplitResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSplitResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSplitResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockMerge) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockMerge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockMerge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockMergeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockMergeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockMergeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SecondBlockId) > 0 {
		i -= len(m.SecondBlockId)
		copy(dAtA[i:], m.SecondBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.SecondBlockId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FirstBlockId) > 0 {
		i -= len(m.FirstBlockId)
		copy(dAtA[i:], m.FirstBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.FirstBlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockMergeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockMergeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockMergeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockMergeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockMergeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockMergeResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCopy) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCopy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCopy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCopyRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCopyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCopyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SelectedTextRange != nil {
		{
			size, err := m.SelectedTextRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCopyResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCopyResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCopyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AnySlot) > 0 {
		for iNdEx := len(m.AnySlot) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AnySlot[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.HtmlSlot) > 0 {
		i -= len(m.HtmlSlot)
		copy(dAtA[i:], m.HtmlSlot)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.HtmlSlot)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TextSlot) > 0 {
		i -= len(m.TextSlot)
		copy(dAtA[i:], m.TextSlot)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TextSlot)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCopyResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCopyResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCopyResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockPaste) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockPaste) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockPaste) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockPasteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockPasteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockPasteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FileSlot) > 0 {
		for iNdEx := len(m.FileSlot) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FileSlot[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.AnySlot) > 0 {
		for iNdEx := len(m.AnySlot) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AnySlot[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.HtmlSlot) > 0 {
		i -= len(m.HtmlSlot)
		copy(dAtA[i:], m.HtmlSlot)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.HtmlSlot)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.TextSlot) > 0 {
		i -= len(m.TextSlot)
		copy(dAtA[i:], m.TextSlot)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TextSlot)))
		i--
		dAtA[i] = 0x32
	}
	if m.IsPartOfBlock {
		i--
		if m.IsPartOfBlock {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.SelectedBlockIds) > 0 {
		for iNdEx := len(m.SelectedBlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SelectedBlockIds[iNdEx])
			copy(dAtA[i:], m.SelectedBlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.SelectedBlockIds[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.SelectedTextRange != nil {
		{
			size, err := m.SelectedTextRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FocusedBlockId) > 0 {
		i -= len(m.FocusedBlockId)
		copy(dAtA[i:], m.FocusedBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.FocusedBlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockPasteRequestFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockPasteRequestFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockPasteRequestFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LocalPath) > 0 {
		i -= len(m.LocalPath)
		copy(dAtA[i:], m.LocalPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.LocalPath)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockPasteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockPasteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockPasteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.IsSameBlockCaret {
		i--
		if m.IsSameBlockCaret {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.CaretPosition != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.CaretPosition))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockPasteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockPasteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockPasteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCut) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCutRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCutRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SelectedTextRange != nil {
		{
			size, err := m.SelectedTextRange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCutResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCutResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.AnySlot) > 0 {
		for iNdEx := len(m.AnySlot) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AnySlot[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.HtmlSlot) > 0 {
		i -= len(m.HtmlSlot)
		copy(dAtA[i:], m.HtmlSlot)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.HtmlSlot)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TextSlot) > 0 {
		i -= len(m.TextSlot)
		copy(dAtA[i:], m.TextSlot)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TextSlot)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCutResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCutResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCutResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockImportMarkdown) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImportMarkdown) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImportMarkdown) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockImportMarkdownRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImportMarkdownRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImportMarkdownRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ImportPath) > 0 {
		i -= len(m.ImportPath)
		copy(dAtA[i:], m.ImportPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ImportPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockImportMarkdownResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImportMarkdownResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImportMarkdownResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RootLinkIds) > 0 {
		for iNdEx := len(m.RootLinkIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RootLinkIds[iNdEx])
			copy(dAtA[i:], m.RootLinkIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RootLinkIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockImportMarkdownResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImportMarkdownResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImportMarkdownResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockExport) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockExportRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockExportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockExportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockExportResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockExportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockExportResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockExportResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockExportResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockExportResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockUploadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUploadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUploadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.FilePath) > 0 {
		i -= len(m.FilePath)
		copy(dAtA[i:], m.FilePath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.FilePath)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUploadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUploadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUploadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUploadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUploadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUploadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDownload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDownload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDownload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDownloadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDownloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDownloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDownloadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDownloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDownloadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDownloadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDownloadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDownloadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFields) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFieldsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFieldsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFieldsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFieldsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFieldsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFieldsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFieldsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFieldsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFieldsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetDetailsDetail) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetDetailsDetail) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetDetailsDetail) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetDetailsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetDetailsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetDetailsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Details) > 0 {
		for iNdEx := len(m.Details) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Details[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetDetailsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetDetailsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetDetailsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetDetailsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetDetailsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetDetailsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetRestrictions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetRestrictions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetRestrictions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetRestrictionsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetRestrictionsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetRestrictionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Restrictions != nil {
		{
			size, err := m.Restrictions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetRestrictionsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetRestrictionsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetRestrictionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetRestrictionsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetRestrictionsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetRestrictionsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetPage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetPage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetPage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetPageIsArchived) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetPageIsArchived) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetPageIsArchived) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetPageIsArchivedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetPageIsArchivedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetPageIsArchivedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsArchived {
		i--
		if m.IsArchived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetPageIsArchivedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetPageIsArchivedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetPageIsArchivedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetPageIsArchivedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetPageIsArchivedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetPageIsArchivedResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLatex) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLatex) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLatex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLatexText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLatexText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLatexText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLatexTextRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLatexTextRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLatexTextRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Text) > 0 {
		i -= len(m.Text)
		copy(dAtA[i:], m.Text)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Text)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLatexTextResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLatexTextResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLatexTextResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLatexTextResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLatexTextResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLatexTextResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextTextRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextTextRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextTextRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Marks != nil {
		{
			size, err := m.Marks.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Text) > 0 {
		i -= len(m.Text)
		copy(dAtA[i:], m.Text)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Text)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextTextResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextTextResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextTextResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextTextResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextTextResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextTextResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextColor) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextColorRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextColorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextColorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextColorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextColorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextColorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextColorResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextColorResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextColorResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextStyleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextStyleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextStyleResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextChecked) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextChecked) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextChecked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextCheckedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextCheckedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextCheckedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Checked {
		i--
		if m.Checked {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextCheckedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextCheckedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextCheckedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextCheckedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextCheckedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextCheckedResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextIcon) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextIcon) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextIcon) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextIconRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextIconRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextIconRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IconEmoji) > 0 {
		i -= len(m.IconEmoji)
		copy(dAtA[i:], m.IconEmoji)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IconEmoji)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.IconImage) > 0 {
		i -= len(m.IconImage)
		copy(dAtA[i:], m.IconImage)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IconImage)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextIconResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextIconResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextIconResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetTextIconResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetTextIconResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetTextIconResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFileName) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFileName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFileName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFileNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFileNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFileNameRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFileNameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFileNameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFileNameResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetFileNameResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetFileNameResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetFileNameResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageName) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageNameRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageNameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageNameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageNameResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageNameResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageNameResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageNameResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageWidth) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageWidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageWidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageWidthRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageWidthRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageWidthRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Width != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageWidthResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageWidthResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageWidthResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetImageWidthResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetImageWidthResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetImageWidthResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoName) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoNameRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoNameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoNameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoNameResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoNameResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoNameResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoNameResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoWidth) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoWidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoWidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoWidthRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoWidthRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoWidthRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Width != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoWidthResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoWidthResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoWidthResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetVideoWidthResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetVideoWidthResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetVideoWidthResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLink) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLinkTargetBlockId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLinkTargetBlockId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLinkTargetBlockId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLinkTargetBlockIdRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLinkTargetBlockIdRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLinkTargetBlockIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TargetBlockId) > 0 {
		i -= len(m.TargetBlockId)
		copy(dAtA[i:], m.TargetBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetBlockId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLinkTargetBlockIdResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLinkTargetBlockIdResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLinkTargetBlockIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetLinkTargetBlockIdResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetLinkTargetBlockIdResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetLinkTargetBlockIdResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationSetKey) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationSetKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationSetKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationSetKeyRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationSetKeyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationSetKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationSetKeyResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationSetKeyResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationSetKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationSetKeyResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationSetKeyResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationSetKeyResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRelationAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRelationAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRelationAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockObjectType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockObjectTypeSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockObjectTypeSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockObjectTypeSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockObjectTypeSetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockObjectTypeSetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockObjectTypeSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectTypeUrl) > 0 {
		i -= len(m.ObjectTypeUrl)
		copy(dAtA[i:], m.ObjectTypeUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeUrl)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockObjectTypeSetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockObjectTypeSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockObjectTypeSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockObjectTypeSetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockObjectTypeSetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockObjectTypeSetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkFetch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkFetch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkFetch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkFetchRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkFetchRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkFetchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkFetchResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkFetchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkFetchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkFetchResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkFetchResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkFetchResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkCreateAndFetch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkCreateAndFetch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkCreateAndFetch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkCreateAndFetchRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkCreateAndFetchRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkCreateAndFetchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x22
	}
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x18
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkCreateAndFetchResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkCreateAndFetchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkCreateAndFetchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockBookmarkCreateAndFetchResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockBookmarkCreateAndFetchResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockBookmarkCreateAndFetchResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockFileCreateAndUpload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileCreateAndUpload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileCreateAndUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockFileCreateAndUploadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileCreateAndUploadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileCreateAndUploadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FileType != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.FileType))
		i--
		dAtA[i] = 0x30
	}
	if len(m.LocalPath) > 0 {
		i -= len(m.LocalPath)
		copy(dAtA[i:], m.LocalPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.LocalPath)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x22
	}
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x18
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockFileCreateAndUploadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileCreateAndUploadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileCreateAndUploadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockFileCreateAndUploadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileCreateAndUploadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileCreateAndUploadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataview) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataview) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.View != nil {
		{
			size, err := m.View.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.View != nil {
		{
			size, err := m.View.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetPosition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetPosition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetPosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetPositionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetPositionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetPositionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetPositionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetPositionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetPositionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetPositionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetPositionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetPositionResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetActive) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetActive) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetActive) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetActiveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetActiveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetActiveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x28
	}
	if m.Offset != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ViewId) > 0 {
		i -= len(m.ViewId)
		copy(dAtA[i:], m.ViewId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ViewId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetActiveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetActiveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetActiveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewViewSetActiveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewViewSetActiveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewViewSetActiveResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Record != nil {
		{
			size, err := m.Record.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TemplateId) > 0 {
		i -= len(m.TemplateId)
		copy(dAtA[i:], m.TemplateId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TemplateId)))
		i--
		dAtA[i] = 0x22
	}
	if m.Record != nil {
		{
			size, err := m.Record.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Record != nil {
		{
			size, err := m.Record.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Option != nil {
		{
			size, err := m.Option.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Option != nil {
		{
			size, err := m.Option.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Option != nil {
		{
			size, err := m.Option.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.OptionId) > 0 {
		i -= len(m.OptionId)
		copy(dAtA[i:], m.OptionId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.OptionId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationListAvailable) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationListAvailable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationListAvailable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationListAvailableRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationListAvailableRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationListAvailableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationListAvailableResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationListAvailableResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationListAvailableResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewRelationListAvailableResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelationListAvailableResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelationListAvailableResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewSetSource) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewSetSource) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewSetSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewSetSourceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewSetSourceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewSetSourceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Source) > 0 {
		for iNdEx := len(m.Source) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Source[iNdEx])
			copy(dAtA[i:], m.Source[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewSetSourceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewSetSourceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewSetSourceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewSetSourceResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewSetSourceResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewSetSourceResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetMarks) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetMarks) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetMarks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetMarksRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetMarksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetMarksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Range != nil {
		{
			size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetMarksResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetMarksResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetMarksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetMarksResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetMarksResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetMarksResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUndoRedoCounter) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUndoRedoCounter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUndoRedoCounter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Redo != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Redo))
		i--
		dAtA[i] = 0x10
	}
	if m.Undo != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Undo))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUndo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUndo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUndo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockUndoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUndoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUndoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUndoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUndoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUndoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counters != nil {
		{
			size, err := m.Counters.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUndoResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUndoResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUndoResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRedo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRedo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRedo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockRedoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRedoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRedoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRedoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRedoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRedoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counters != nil {
		{
			size, err := m.Counters.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockRedoResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockRedoResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockRedoResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpen) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpen) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockShow) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockShow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockShowRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockShowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockShowRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockShowResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockShowResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockShowResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockShowResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockShowResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockShowResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetPublicWebURL) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetPublicWebURL) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetPublicWebURL) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetPublicWebURLRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetPublicWebURLRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetPublicWebURLRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetPublicWebURLResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetPublicWebURLResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetPublicWebURLResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockGetPublicWebURLResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockGetPublicWebURLResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockGetPublicWebURLResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenBreadcrumbs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenBreadcrumbs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenBreadcrumbs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenBreadcrumbsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenBreadcrumbsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenBreadcrumbsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenBreadcrumbsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenBreadcrumbsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenBreadcrumbsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenBreadcrumbsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenBreadcrumbsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenBreadcrumbsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetBreadcrumbs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetBreadcrumbs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetBreadcrumbs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetBreadcrumbsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetBreadcrumbsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetBreadcrumbsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.BreadcrumbsId) > 0 {
		i -= len(m.BreadcrumbsId)
		copy(dAtA[i:], m.BreadcrumbsId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BreadcrumbsId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetBreadcrumbsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetBreadcrumbsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetBreadcrumbsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockSetBreadcrumbsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockSetBreadcrumbsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockSetBreadcrumbsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x20
	}
	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] = 0x1a
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreatePage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreatePage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreatePage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreatePageRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreatePageRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreatePageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Fields != nil {
		{
			size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.TemplateId) > 0 {
		i -= len(m.TemplateId)
		copy(dAtA[i:], m.TemplateId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TemplateId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x20
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreatePageResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreatePageResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreatePageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreatePageResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreatePageResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreatePageResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateSetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateSetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x28
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Source) > 0 {
		for iNdEx := len(m.Source) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Source[iNdEx])
			copy(dAtA[i:], m.Source[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateSetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.TargetId) > 0 {
		i -= len(m.TargetId)
		copy(dAtA[i:], m.TargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateSetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateSetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateSetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUnlink) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUnlink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUnlink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockUnlinkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUnlinkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUnlinkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockIds) > 0 {
		for iNdEx := len(m.BlockIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.BlockIds[iNdEx])
			copy(dAtA[i:], m.BlockIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUnlinkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUnlinkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUnlinkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUnlinkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUnlinkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUnlinkResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockClose) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockClose) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockClose) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCloseRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCloseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCloseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCloseResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCloseResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCloseResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCloseResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCloseResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCloseResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspace) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetCurrent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetCurrent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetCurrent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetCurrentRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetCurrentRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetCurrentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetCurrentResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetCurrentResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetCurrentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.WorkspaceId) > 0 {
		i -= len(m.WorkspaceId)
		copy(dAtA[i:], m.WorkspaceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.WorkspaceId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetCurrentResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetCurrentResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetCurrentResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetAll) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetAll) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetAll) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetAllRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetAllRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetAllRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetAllResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetAllResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetAllResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.WorkspaceIds) > 0 {
		for iNdEx := len(m.WorkspaceIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.WorkspaceIds[iNdEx])
			copy(dAtA[i:], m.WorkspaceIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.WorkspaceIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceGetAllResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceGetAllResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceGetAllResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.WorkspaceId) > 0 {
		i -= len(m.WorkspaceId)
		copy(dAtA[i:], m.WorkspaceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.WorkspaceId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSetIsHighlighted) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSetIsHighlighted) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSetIsHighlighted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSetIsHighlightedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSetIsHighlightedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSetIsHighlightedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsHighlighted {
		i--
		if m.IsHighlighted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSetIsHighlightedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSetIsHighlightedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSetIsHighlightedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSetIsHighlightedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSetIsHighlightedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSetIsHighlightedResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSelect) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSelect) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSelect) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSelectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSelectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSelectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.WorkspaceId) > 0 {
		i -= len(m.WorkspaceId)
		copy(dAtA[i:], m.WorkspaceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.WorkspaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSelectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSelectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSelectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceSelectResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceSelectResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceSelectResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWallet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWallet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWallet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWalletCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWalletCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RootPath) > 0 {
		i -= len(m.RootPath)
		copy(dAtA[i:], m.RootPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RootPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Mnemonic) > 0 {
		i -= len(m.Mnemonic)
		copy(dAtA[i:], m.Mnemonic)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Mnemonic)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletRecover) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletRecover) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletRecover) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWalletRecoverRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletRecoverRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletRecoverRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Mnemonic) > 0 {
		i -= len(m.Mnemonic)
		copy(dAtA[i:], m.Mnemonic)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Mnemonic)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RootPath) > 0 {
		i -= len(m.RootPath)
		copy(dAtA[i:], m.RootPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RootPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletRecoverResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletRecoverResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletRecoverResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletRecoverResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletRecoverResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletRecoverResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletConvert) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletConvert) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletConvert) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWalletConvertRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletConvertRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletConvertRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Entropy) > 0 {
		i -= len(m.Entropy)
		copy(dAtA[i:], m.Entropy)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Entropy)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Mnemonic) > 0 {
		i -= len(m.Mnemonic)
		copy(dAtA[i:], m.Mnemonic)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Mnemonic)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletConvertResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletConvertResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletConvertResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Mnemonic) > 0 {
		i -= len(m.Mnemonic)
		copy(dAtA[i:], m.Mnemonic)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Mnemonic)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Entropy) > 0 {
		i -= len(m.Entropy)
		copy(dAtA[i:], m.Entropy)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Entropy)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletConvertResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletConvertResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletConvertResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccount) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccount) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Extra != nil {
		{
			size, err := m.Extra.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xa2
	}
	if m.EnableSpaces {
		i--
		if m.EnableSpaces {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.EnableReleaseChannelSwitch {
		i--
		if m.EnableReleaseChannelSwitch {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.EnableDebug {
		i--
		if m.EnableDebug {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.EnableDataview {
		i--
		if m.EnableDataview {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AlphaInviteCode) > 0 {
		i -= len(m.AlphaInviteCode)
		copy(dAtA[i:], m.AlphaInviteCode)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.AlphaInviteCode)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if m.Avatar != nil {
		{
			size := m.Avatar.Size()
			i -= size
			if _, err := m.Avatar.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountCreateRequestAvatarOfAvatarLocalPath) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreateRequestAvatarOfAvatarLocalPath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.AvatarLocalPath)
	copy(dAtA[i:], m.AvatarLocalPath)
	i = encodeVarintCommands(dAtA, i, uint64(len(m.AvatarLocalPath)))
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}
func (m *RpcAccountCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Account != nil {
		{
			size, err := m.Account.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecover) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecover) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecover) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecoverRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecoverRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecoverRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecoverResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecoverResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecoverResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecoverResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecoverResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecoverResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelect) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelect) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelect) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RootPath) > 0 {
		i -= len(m.RootPath)
		copy(dAtA[i:], m.RootPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RootPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Account != nil {
		{
			size, err := m.Account.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelectResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelectResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelectResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountStop) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountStop) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountStop) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountStopRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountStopRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountStopRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RemoveData {
		i--
		if m.RemoveData {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountStopResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountStopResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountStopResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountStopResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountStopResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountStopResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcLog) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLog) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLog) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcLogSend) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcLogSendRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSendRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSendRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Level != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Level))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcLogSendResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSendResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSendResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcLogSendResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSendResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSendResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcVersionGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcVersionGetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcVersionGetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Details) > 0 {
		i -= len(m.Details)
		copy(dAtA[i:], m.Details)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Details)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcVersionGetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileOffload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileOffload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileOffload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileOffloadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileOffloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileOffloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IncludeNotPinned {
		i--
		if m.IncludeNotPinned {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcFileOffloadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileOffloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileOffloadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BytesOffloaded != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.BytesOffloaded))
		i--
		dAtA[i] = 0x10
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcFileOffloadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileOffloadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileOffloadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcFileList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileListOffload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileListOffload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileListOffload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileListOffloadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileListOffloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileListOffloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IncludeNotPinned {
		i--
		if m.IncludeNotPinned {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.OnlyIds) > 0 {
		for iNdEx := len(m.OnlyIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.OnlyIds[iNdEx])
			copy(dAtA[i:], m.OnlyIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.OnlyIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcFileListOffloadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileListOffloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileListOffloadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BytesOffloaded != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.BytesOffloaded))
		i--
		dAtA[i] = 0x18
	}
	if m.FilesOffloaded != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.FilesOffloaded))
		i--
		dAtA[i] = 0x10
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcFileListOffloadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileListOffloadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileListOffloadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcShutdown) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcShutdown) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcShutdown) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcShutdownRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcShutdownRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcShutdownRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcShutdownResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcShutdownResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcShutdownResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcShutdownResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcShutdownResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcShutdownResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcConfigGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcConfigGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcConfigGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcConfigGetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcConfigGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcConfigGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcConfigGetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcConfigGetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcConfigGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.GatewayUrl) > 0 {
		i -= len(m.GatewayUrl)
		copy(dAtA[i:], m.GatewayUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.GatewayUrl)))
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0xaa
	}
	if len(m.DeviceId) > 0 {
		i -= len(m.DeviceId)
		copy(dAtA[i:], m.DeviceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DeviceId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.MarketplaceTemplateId) > 0 {
		i -= len(m.MarketplaceTemplateId)
		copy(dAtA[i:], m.MarketplaceTemplateId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.MarketplaceTemplateId)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.MarketplaceRelationId) > 0 {
		i -= len(m.MarketplaceRelationId)
		copy(dAtA[i:], m.MarketplaceRelationId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.MarketplaceRelationId)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.MarketplaceTypeId) > 0 {
		i -= len(m.MarketplaceTypeId)
		copy(dAtA[i:], m.MarketplaceTypeId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.MarketplaceTypeId)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ProfileBlockId) > 0 {
		i -= len(m.ProfileBlockId)
		copy(dAtA[i:], m.ProfileBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ProfileBlockId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ArchiveBlockId) > 0 {
		i -= len(m.ArchiveBlockId)
		copy(dAtA[i:], m.ArchiveBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ArchiveBlockId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.HomeBlockId) > 0 {
		i -= len(m.HomeBlockId)
		copy(dAtA[i:], m.HomeBlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.HomeBlockId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcConfigGetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcConfigGetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcConfigGetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcPing) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPing) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcPingRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumberOfEventsToSend != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.NumberOfEventsToSend))
		i--
		dAtA[i] = 0x10
	}
	if m.Index != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcPingResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPingResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcPingResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPingResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPingResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcProcess) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcProcess) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcProcess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcProcessCancel) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcProcessCancel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcProcessCancel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcProcessCancelRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcProcessCancelRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcProcessCancelRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcProcessCancelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcProcessCancelResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcProcessCancelResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcProcessCancelResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcProcessCancelResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcProcessCancelResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcLinkPreview) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLinkPreview) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLinkPreview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcLinkPreviewRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLinkPreviewRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLinkPreviewRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcLinkPreviewResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLinkPreviewResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLinkPreviewResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LinkPreview != nil {
		{
			size, err := m.LinkPreview.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcLinkPreviewResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLinkPreviewResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLinkPreviewResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcUploadFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUploadFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUploadFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcUploadFileRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUploadFileRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUploadFileRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Style != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Style))
		i--
		dAtA[i] = 0x28
	}
	if m.DisableEncryption {
		i--
		if m.DisableEncryption {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Type != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if len(m.LocalPath) > 0 {
		i -= len(m.LocalPath)
		copy(dAtA[i:], m.LocalPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.LocalPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUploadFileResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUploadFileResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUploadFileResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUploadFileResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUploadFileResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUploadFileResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcDownloadFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDownloadFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDownloadFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDownloadFileRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDownloadFileRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDownloadFileRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDownloadFileResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDownloadFileResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDownloadFileResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LocalPath) > 0 {
		i -= len(m.LocalPath)
		copy(dAtA[i:], m.LocalPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.LocalPath)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDownloadFileResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDownloadFileResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDownloadFileResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcNavigation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcNavigationListObjects) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationListObjects) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationListObjects) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcNavigationListObjectsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationListObjectsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationListObjectsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Offset != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x20
	}
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x18
	}
	if len(m.FullText) > 0 {
		i -= len(m.FullText)
		copy(dAtA[i:], m.FullText)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.FullText)))
		i--
		dAtA[i] = 0x12
	}
	if m.Context != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Context))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcNavigationListObjectsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationListObjectsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationListObjectsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Objects) > 0 {
		for iNdEx := len(m.Objects) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Objects[iNdEx].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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcNavigationListObjectsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationListObjectsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationListObjectsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcNavigationGetObjectInfoWithLinks) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationGetObjectInfoWithLinks) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationGetObjectInfoWithLinks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcNavigationGetObjectInfoWithLinksRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationGetObjectInfoWithLinksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationGetObjectInfoWithLinksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Context != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Context))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcNavigationGetObjectInfoWithLinksResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationGetObjectInfoWithLinksResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationGetObjectInfoWithLinksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Object != nil {
		{
			size, err := m.Object.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistory) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistory) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcHistoryVersions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryVersions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryVersions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcHistoryVersionsVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryVersionsVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryVersionsVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GroupId != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.GroupId))
		i--
		dAtA[i] = 0x30
	}
	if m.Time != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x28
	}
	if len(m.AuthorName) > 0 {
		i -= len(m.AuthorName)
		copy(dAtA[i:], m.AuthorName)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.AuthorName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.AuthorId) > 0 {
		i -= len(m.AuthorId)
		copy(dAtA[i:], m.AuthorId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.AuthorId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PreviousIds) > 0 {
		for iNdEx := len(m.PreviousIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PreviousIds[iNdEx])
			copy(dAtA[i:], m.PreviousIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.PreviousIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistoryVersionsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryVersionsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryVersionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x18
	}
	if len(m.LastVersionId) > 0 {
		i -= len(m.LastVersionId)
		copy(dAtA[i:], m.LastVersionId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.LastVersionId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PageId) > 0 {
		i -= len(m.PageId)
		copy(dAtA[i:], m.PageId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.PageId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistoryVersionsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryVersionsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryVersionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Versions) > 0 {
		for iNdEx := len(m.Versions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Versions[iNdEx].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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistoryVersionsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryVersionsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryVersionsResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistoryShow) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcHistoryShowRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.VersionId) > 0 {
		i -= len(m.VersionId)
		copy(dAtA[i:], m.VersionId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.VersionId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PageId) > 0 {
		i -= len(m.PageId)
		copy(dAtA[i:], m.PageId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.PageId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistoryShowResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TraceId) > 0 {
		i -= len(m.TraceId)
		copy(dAtA[i:], m.TraceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TraceId)))
		i--
		dAtA[i] = 0x22
	}
	if m.Version != nil {
		{
			size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectShow != nil {
		{
			size, err := m.ObjectShow.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistoryShowResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistorySetVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistorySetVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistorySetVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcHistorySetVersionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistorySetVersionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistorySetVersionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VersionId) > 0 {
		i -= len(m.VersionId)
		copy(dAtA[i:], m.VersionId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.VersionId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PageId) > 0 {
		i -= len(m.PageId)
		copy(dAtA[i:], m.PageId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.PageId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistorySetVersionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistorySetVersionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistorySetVersionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcHistorySetVersionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistorySetVersionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistorySetVersionResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcPage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcPageCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPageCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPageCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcPageCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPageCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPageCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcPageCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPageCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPageCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.PageId) > 0 {
		i -= len(m.PageId)
		copy(dAtA[i:], m.PageId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.PageId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcPageCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcPageCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcPageCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcSetCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcSetCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcSetCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcSetCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcSetCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcSetCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TemplateId) > 0 {
		i -= len(m.TemplateId)
		copy(dAtA[i:], m.TemplateId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TemplateId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Source) > 0 {
		for iNdEx := len(m.Source) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Source[iNdEx])
			copy(dAtA[i:], m.Source[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcSetCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcSetCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcSetCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcSetCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcSetCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcSetCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeListRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeListRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeListResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeListResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectTypes) > 0 {
		for iNdEx := len(m.ObjectTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ObjectTypes[iNdEx].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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeListResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeListResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeListResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ObjectType != nil {
		{
			size, err := m.ObjectType.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ObjectType != nil {
		{
			size, err := m.ObjectType.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ObjectTypeUrl) > 0 {
		i -= len(m.ObjectTypeUrl)
		copy(dAtA[i:], m.ObjectTypeUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeUrl)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationRemoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationRemoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationRemoveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ObjectTypeUrl) > 0 {
		i -= len(m.ObjectTypeUrl)
		copy(dAtA[i:], m.ObjectTypeUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeUrl)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationRemoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationRemoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationRemoveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationRemoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationRemoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationRemoveResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ObjectTypeUrl) > 0 {
		i -= len(m.ObjectTypeUrl)
		copy(dAtA[i:], m.ObjectTypeUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeUrl)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationListRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationListRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AppendRelationsFromOtherTypes {
		i--
		if m.AppendRelationsFromOtherTypes {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ObjectTypeUrl) > 0 {
		i -= len(m.ObjectTypeUrl)
		copy(dAtA[i:], m.ObjectTypeUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeUrl)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationListResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationListResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectTypeRelationListResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectTypeRelationListResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectTypeRelationListResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectShareByLink) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShareByLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShareByLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectShareByLinkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShareByLinkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShareByLinkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectShareByLinkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShareByLinkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShareByLinkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Link) > 0 {
		i -= len(m.Link)
		copy(dAtA[i:], m.Link)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Link)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectShareByLinkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShareByLinkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShareByLinkResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectAddWithObjectId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectAddWithObjectId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectAddWithObjectId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectAddWithObjectIdRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectAddWithObjectIdRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectAddWithObjectIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectAddWithObjectIdResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectAddWithObjectIdResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectAddWithObjectIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectAddWithObjectIdResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectAddWithObjectIdResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectAddWithObjectIdResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Option != nil {
		{
			size, err := m.Option.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Option != nil {
		{
			size, err := m.Option.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Option != nil {
		{
			size, err := m.Option.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConfirmRemoveAllValuesInRecords {
		i--
		if m.ConfirmRemoveAllValuesInRecords {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.OptionId) > 0 {
		i -= len(m.OptionId)
		copy(dAtA[i:], m.OptionId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.OptionId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RelationKey) > 0 {
		i -= len(m.RelationKey)
		copy(dAtA[i:], m.RelationKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationOptionDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationOptionDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationOptionDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationListAvailable) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationListAvailable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationListAvailable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationListAvailableRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationListAvailableRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationListAvailableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationListAvailableResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationListAvailableResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationListAvailableResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Relations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationListAvailableResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationListAvailableResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationListAvailableResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Keys[iNdEx])
			copy(dAtA[i:], m.Keys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Keys[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.ObjectTypeFilter) > 0 {
		for iNdEx := len(m.ObjectTypeFilter) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectTypeFilter[iNdEx])
			copy(dAtA[i:], m.ObjectTypeFilter[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeFilter[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x28
	}
	if m.Offset != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x20
	}
	if len(m.FullText) > 0 {
		i -= len(m.FullText)
		copy(dAtA[i:], m.FullText)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.FullText)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Sorts) > 0 {
		for iNdEx := len(m.Sorts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sorts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Filters) > 0 {
		for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Filters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectGraph) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGraph) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGraph) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectGraphRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGraphRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGraphRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectTypeFilter) > 0 {
		for iNdEx := len(m.ObjectTypeFilter) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectTypeFilter[iNdEx])
			copy(dAtA[i:], m.ObjectTypeFilter[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectTypeFilter[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Filters) > 0 {
		for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Filters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectGraphNode) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGraphNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGraphNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Snippet) > 0 {
		i -= len(m.Snippet)
		copy(dAtA[i:], m.Snippet)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Snippet)))
		i--
		dAtA[i] = 0x52
	}
	if m.RelationFormat != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.RelationFormat))
		i--
		dAtA[i] = 0x48
	}
	if m.Done {
		i--
		if m.Done {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.IconEmoji) > 0 {
		i -= len(m.IconEmoji)
		copy(dAtA[i:], m.IconEmoji)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IconEmoji)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.IconImage) > 0 {
		i -= len(m.IconImage)
		copy(dAtA[i:], m.IconImage)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IconImage)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Layout != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Layout))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectGraphEdge) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGraphEdge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGraphEdge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Hidden {
		i--
		if m.Hidden {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.IconEmoji) > 0 {
		i -= len(m.IconEmoji)
		copy(dAtA[i:], m.IconEmoji)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IconEmoji)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.IconImage) > 0 {
		i -= len(m.IconImage)
		copy(dAtA[i:], m.IconImage)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IconImage)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Type != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Target) > 0 {
		i -= len(m.Target)
		copy(dAtA[i:], m.Target)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Target)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Source) > 0 {
		i -= len(m.Source)
		copy(dAtA[i:], m.Source)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Source)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectGraphResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGraphResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGraphResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Edges) > 0 {
		for iNdEx := len(m.Edges) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Edges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Nodes) > 0 {
		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Nodes[iNdEx].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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectGraphResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGraphResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGraphResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchSubscribe) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchSubscribe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchSubscribe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchSubscribeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchSubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchSubscribeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NoDepSubscription {
		i--
		if m.NoDepSubscription {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if len(m.IgnoreWorkspace) > 0 {
		i -= len(m.IgnoreWorkspace)
		copy(dAtA[i:], m.IgnoreWorkspace)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IgnoreWorkspace)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.Source) > 0 {
		for iNdEx := len(m.Source) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Source[iNdEx])
			copy(dAtA[i:], m.Source[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.BeforeId) > 0 {
		i -= len(m.BeforeId)
		copy(dAtA[i:], m.BeforeId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BeforeId)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.AfterId) > 0 {
		i -= len(m.AfterId)
		copy(dAtA[i:], m.AfterId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.AfterId)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Keys[iNdEx])
			copy(dAtA[i:], m.Keys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Keys[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Offset != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x30
	}
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Sorts) > 0 {
		for iNdEx := len(m.Sorts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sorts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Filters) > 0 {
		for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Filters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchSubscribeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchSubscribeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchSubscribeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counters != nil {
		{
			size, err := m.Counters.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Dependencies) > 0 {
		for iNdEx := len(m.Dependencies) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Dependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchSubscribeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchSubscribeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchSubscribeResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectIdsSubscribe) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectIdsSubscribe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectIdsSubscribe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectIdsSubscribeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectIdsSubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectIdsSubscribeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IgnoreWorkspace) > 0 {
		i -= len(m.IgnoreWorkspace)
		copy(dAtA[i:], m.IgnoreWorkspace)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IgnoreWorkspace)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Keys) > 0 {
		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Keys[iNdEx])
			copy(dAtA[i:], m.Keys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Keys[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Ids) > 0 {
		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Ids[iNdEx])
			copy(dAtA[i:], m.Ids[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Ids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectIdsSubscribeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectIdsSubscribeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectIdsSubscribeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubId) > 0 {
		i -= len(m.SubId)
		copy(dAtA[i:], m.SubId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.SubId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Dependencies) > 0 {
		for iNdEx := len(m.Dependencies) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Dependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectIdsSubscribeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectIdsSubscribeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectIdsSubscribeResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchUnsubscribe) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchUnsubscribe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchUnsubscribe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchUnsubscribeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchUnsubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchUnsubscribeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for iNdEx := len(m.SubIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SubIds[iNdEx])
			copy(dAtA[i:], m.SubIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.SubIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchUnsubscribeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchUnsubscribeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchUnsubscribeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSearchUnsubscribeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSearchUnsubscribeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSearchUnsubscribeResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetLayout) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetLayout) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetLayout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetLayoutRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetLayoutRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetLayoutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Layout != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Layout))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetLayoutResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetLayoutResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetLayoutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetLayoutResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetLayoutResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetLayoutResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsFavorite) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsFavorite) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsFavorite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsFavoriteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsFavoriteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsFavoriteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsFavorite {
		i--
		if m.IsFavorite {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsFavoriteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsFavoriteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsFavoriteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsFavoriteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsFavoriteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsFavoriteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsArchived) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsArchived) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsArchived) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsArchivedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsArchivedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsArchivedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsArchived {
		i--
		if m.IsArchived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsArchivedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsArchivedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsArchivedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetIsArchivedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetIsArchivedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetIsArchivedResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Relations[iNdEx])
			copy(dAtA[i:], m.Relations[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Relations[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationAddResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationRemoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationRemoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationRemoveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Relations) > 0 {
		for iNdEx := len(m.Relations) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Relations[iNdEx])
			copy(dAtA[i:], m.Relations[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Relations[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationRemoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationRemoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationRemoveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectFeaturedRelationRemoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectFeaturedRelationRemoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectFeaturedRelationRemoveResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectToSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectToSetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToSetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Source) > 0 {
		for iNdEx := len(m.Source) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Source[iNdEx])
			copy(dAtA[i:], m.Source[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.Source[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectToSetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SetId) > 0 {
		i -= len(m.SetId)
		copy(dAtA[i:], m.SetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.SetId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectToSetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToSetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToSetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectIds) > 0 {
		for iNdEx := len(m.ObjectIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectIds[iNdEx])
			copy(dAtA[i:], m.ObjectIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDeleteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsArchived) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsArchived) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsArchived) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsArchivedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsArchivedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsArchivedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsArchived {
		i--
		if m.IsArchived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ObjectIds) > 0 {
		for iNdEx := len(m.ObjectIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectIds[iNdEx])
			copy(dAtA[i:], m.ObjectIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsArchivedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsArchivedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsArchivedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsArchivedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsArchivedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsArchivedResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsFavorite) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsFavorite) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsFavorite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsFavoriteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsFavoriteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsFavoriteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsFavorite {
		i--
		if m.IsFavorite {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ObjectIds) > 0 {
		for iNdEx := len(m.ObjectIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ObjectIds[iNdEx])
			copy(dAtA[i:], m.ObjectIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsFavoriteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsFavoriteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsFavoriteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectListSetIsFavoriteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListSetIsFavoriteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListSetIsFavoriteResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcExport) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExportRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IncludeFiles {
		i--
		if m.IncludeFiles {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.IncludeNested {
		i--
		if m.IncludeNested {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Zip {
		i--
		if m.Zip {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Format != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Format))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DocIds) > 0 {
		for iNdEx := len(m.DocIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DocIds[iNdEx])
			copy(dAtA[i:], m.DocIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.DocIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Succeed != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Succeed))
		i--
		dAtA[i] = 0x20
	}
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportWorkspace) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportWorkspace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportWorkspace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExportWorkspaceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportWorkspaceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportWorkspaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.WorkspaceId) > 0 {
		i -= len(m.WorkspaceId)
		copy(dAtA[i:], m.WorkspaceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.WorkspaceId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportWorkspaceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportWorkspaceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportWorkspaceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportWorkspaceResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportWorkspaceResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportWorkspaceResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportTemplates) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportTemplates) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportTemplates) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExportTemplatesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportTemplatesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportTemplatesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportTemplatesResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportTemplatesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportTemplatesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportTemplatesResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportTemplatesResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportTemplatesResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportLocalstore) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportLocalstore) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportLocalstore) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcExportLocalstoreRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportLocalstoreRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportLocalstoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DocIds) > 0 {
		for iNdEx := len(m.DocIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DocIds[iNdEx])
			copy(dAtA[i:], m.DocIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.DocIds[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportLocalstoreResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportLocalstoreResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportLocalstoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcExportLocalstoreResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcExportLocalstoreResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcExportLocalstoreResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateByObjectType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateByObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateByObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateByObjectTypeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateByObjectTypeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateByObjectTypeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectType) > 0 {
		i -= len(m.ObjectType)
		copy(dAtA[i:], m.ObjectType)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectType)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateByObjectTypeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateByObjectTypeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateByObjectTypeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcMakeTemplateByObjectTypeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcMakeTemplateByObjectTypeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcMakeTemplateByObjectTypeResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcCloneTemplate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcCloneTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcCloneTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcCloneTemplateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcCloneTemplateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcCloneTemplateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcCloneTemplateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcCloneTemplateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcCloneTemplateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcCloneTemplateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcCloneTemplateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcCloneTemplateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectDuplicate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectDuplicate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectDuplicateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectDuplicateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectDuplicateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectDuplicateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectDuplicateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectDuplicateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectDuplicateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectDuplicateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectDuplicateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashSearch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashSearch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashSearch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashSearchRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashSearchRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashSearchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Limit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Query) > 0 {
		i -= len(m.Query)
		copy(dAtA[i:], m.Query)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Query)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashSearchResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashSearchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashSearchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Pictures) > 0 {
		for iNdEx := len(m.Pictures) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Pictures[iNdEx].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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashSearchResponsePicture) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashSearchResponsePicture) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashSearchResponsePicture) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ArtistUrl) > 0 {
		i -= len(m.ArtistUrl)
		copy(dAtA[i:], m.ArtistUrl)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ArtistUrl)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Artist) > 0 {
		i -= len(m.Artist)
		copy(dAtA[i:], m.Artist)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Artist)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashSearchResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashSearchResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashSearchResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashDownload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashDownload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashDownload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashDownloadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashDownloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashDownloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PictureId) > 0 {
		i -= len(m.PictureId)
		copy(dAtA[i:], m.PictureId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.PictureId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashDownloadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashDownloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashDownloadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcUnsplashDownloadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplashDownloadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplashDownloadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcApplyTemplate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcApplyTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcApplyTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcApplyTemplateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcApplyTemplateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcApplyTemplateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TemplateId) > 0 {
		i -= len(m.TemplateId)
		copy(dAtA[i:], m.TemplateId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TemplateId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContextId) > 0 {
		i -= len(m.ContextId)
		copy(dAtA[i:], m.ContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ContextId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcApplyTemplateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcApplyTemplateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcApplyTemplateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcApplyTemplateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcApplyTemplateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcApplyTemplateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebug) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebug) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebug) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDebuglogInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebuglogInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebuglogInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.DownStatus) > 0 {
		i -= len(m.DownStatus)
		copy(dAtA[i:], m.DownStatus)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DownStatus)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.UpStatus) > 0 {
		i -= len(m.UpStatus)
		copy(dAtA[i:], m.UpStatus)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.UpStatus)))
		i--
		dAtA[i] = 0x5a
	}
	if m.LastPullSecAgo != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.LastPullSecAgo))
		i--
		dAtA[i] = 0x50
	}
	if m.LastRecordVer != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.LastRecordVer))
		i--
		dAtA[i] = 0x48
	}
	if m.LastRecordTs != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.LastRecordTs))
		i--
		dAtA[i] = 0x40
	}
	if m.FirstRecordVer != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.FirstRecordVer))
		i--
		dAtA[i] = 0x38
	}
	if m.FirstRecordTs != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.FirstRecordTs))
		i--
		dAtA[i] = 0x30
	}
	if m.TotalSize != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalSize))
		i--
		dAtA[i] = 0x28
	}
	if m.TotalRecords != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalRecords))
		i--
		dAtA[i] = 0x20
	}
	if m.HeadDownloaded {
		i--
		if m.HeadDownloaded {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Head) > 0 {
		i -= len(m.Head)
		copy(dAtA[i:], m.Head)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Head)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugthreadInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugthreadInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugthreadInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x5a
	}
	if m.TotalSize != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalSize))
		i--
		dAtA[i] = 0x50
	}
	if m.TotalRecords != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalRecords))
		i--
		dAtA[i] = 0x48
	}
	if len(m.CafeDownStatus) > 0 {
		i -= len(m.CafeDownStatus)
		copy(dAtA[i:], m.CafeDownStatus)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.CafeDownStatus)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.CafeUpStatus) > 0 {
		i -= len(m.CafeUpStatus)
		copy(dAtA[i:], m.CafeUpStatus)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.CafeUpStatus)))
		i--
		dAtA[i] = 0x3a
	}
	if m.CafeLastPullSecAgo != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.CafeLastPullSecAgo))
		i--
		dAtA[i] = 0x30
	}
	if m.OwnLogHasCafeReplicator {
		i--
		if m.OwnLogHasCafeReplicator {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.LogsWithWholeTreeDownloaded != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.LogsWithWholeTreeDownloaded))
		i--
		dAtA[i] = 0x18
	}
	if m.LogsWithDownloadedHead != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.LogsWithDownloadedHead))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugSync) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugSync) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugSync) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDebugSyncRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TryToDownloadRemoteRecords {
		i--
		if m.TryToDownloadRemoteRecords {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.SkipEmptyLogs {
		i--
		if m.SkipEmptyLogs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.RecordsTraverseLimit != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.RecordsTraverseLimit))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugSyncResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TotalSize != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalSize))
		i--
		dAtA[i] = 0x40
	}
	if m.TotalRecords != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalRecords))
		i--
		dAtA[i] = 0x38
	}
	if m.ThreadsWithoutHeadDownloaded != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.ThreadsWithoutHeadDownloaded))
		i--
		dAtA[i] = 0x30
	}
	if m.ThreadsWithoutReplInOwnLog != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.ThreadsWithoutReplInOwnLog))
		i--
		dAtA[i] = 0x28
	}
	if m.TotalThreads != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.TotalThreads))
		i--
		dAtA[i] = 0x20
	}
	if len(m.DeviceId) > 0 {
		i -= len(m.DeviceId)
		copy(dAtA[i:], m.DeviceId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DeviceId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Threads) > 0 {
		for iNdEx := len(m.Threads) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Threads[iNdEx].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])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugSyncResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugSyncResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugSyncResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugThread) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugThread) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugThread) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDebugThreadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugThreadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugThreadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TryToDownloadRemoteRecords {
		i--
		if m.TryToDownloadRemoteRecords {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.SkipEmptyLogs {
		i--
		if m.SkipEmptyLogs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ThreadId) > 0 {
		i -= len(m.ThreadId)
		copy(dAtA[i:], m.ThreadId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ThreadId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugThreadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugThreadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugThreadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Info != nil {
		{
			size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugThreadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugThreadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugThreadResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugTree) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugTree) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugTree) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDebugTreeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugTreeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugTreeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Unanonymized {
		i--
		if m.Unanonymized {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugTreeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugTreeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugTreeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Filename) > 0 {
		i -= len(m.Filename)
		copy(dAtA[i:], m.Filename)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Filename)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcDebugTreeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugTreeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugTreeResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcGenericErrorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcGenericErrorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcGenericErrorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcGenericErrorResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcGenericErrorResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcGenericErrorResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Empty) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Empty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintCommands(dAtA []byte, offset int, v uint64) int {
	offset -= sovCommands(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Rpc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcMetrics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcMetricsSetParameters) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcMetricsSetParametersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Platform)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMetricsSetParametersResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMetricsSetParametersResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExternalDrop) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExternalDropFiles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExternalDropFilesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.DropTargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	if len(m.LocalFilePaths) > 0 {
		for _, s := range m.LocalFilePaths {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcExternalDropFilesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExternalDropFilesResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExternalDropContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExternalDropContentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.FocusedBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExternalDropContentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExternalDropContentResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListConvertChildrenToPages) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListConvertChildrenToPagesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.ObjectType)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListConvertChildrenToPagesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.LinkIds) > 0 {
		for _, s := range m.LinkIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockListConvertChildrenToPagesResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListMoveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.TargetContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.DropTargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockListMoveResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListMoveResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListMoveToNewPage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListMoveToNewPageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.DropTargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockListMoveToNewPageResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.LinkId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListMoveToNewPageResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListDuplicateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockListDuplicateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListDuplicateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetTextStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetTextStyleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	return n
}

func (m *RpcBlockListSetTextStyleResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextStyleResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetTextColorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextColorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextColorResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextMark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetTextMarkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Mark != nil {
		l = m.Mark.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextMarkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetTextMarkResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetBackgroundColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetBackgroundColorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetBackgroundColorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetBackgroundColorResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetAlignRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Align != 0 {
		n += 1 + sovCommands(uint64(m.Align))
	}
	return n
}

func (m *RpcBlockListSetAlignResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetAlignResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetFieldsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockFields) > 0 {
		for _, e := range m.BlockFields {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockListSetFieldsRequestBlockField) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetFieldsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetFieldsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetDivStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetDivStyleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	return n
}

func (m *RpcBlockListSetDivStyleResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetDivStyleResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetFileStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetFileStyleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	return n
}

func (m *RpcBlockListSetFileStyleResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListSetFileStyleResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListTurnInto) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListTurnIntoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	return n
}

func (m *RpcBlockListTurnIntoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListTurnIntoResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockReplace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockReplaceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Block != nil {
		l = m.Block.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockReplaceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockReplaceResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUpdateContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockUpdateContentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Block != nil {
		l = m.Block.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUpdateContentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUpdateContentResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSplit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSplitRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	if m.Mode != 0 {
		n += 1 + sovCommands(uint64(m.Mode))
	}
	return n
}

func (m *RpcBlockSplitResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSplitResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockMerge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockMergeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.FirstBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.SecondBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockMergeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockMergeResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCopy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCopyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.SelectedTextRange != nil {
		l = m.SelectedTextRange.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCopyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TextSlot)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.HtmlSlot)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.AnySlot) > 0 {
		for _, e := range m.AnySlot {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockCopyResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockPaste) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockPasteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.FocusedBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.SelectedTextRange != nil {
		l = m.SelectedTextRange.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.SelectedBlockIds) > 0 {
		for _, s := range m.SelectedBlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.IsPartOfBlock {
		n += 2
	}
	l = len(m.TextSlot)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.HtmlSlot)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.AnySlot) > 0 {
		for _, e := range m.AnySlot {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.FileSlot) > 0 {
		for _, e := range m.FileSlot {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockPasteRequestFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.LocalPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockPasteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.CaretPosition != 0 {
		n += 1 + sovCommands(uint64(m.CaretPosition))
	}
	if m.IsSameBlockCaret {
		n += 2
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockPasteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCut) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.SelectedTextRange != nil {
		l = m.SelectedTextRange.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TextSlot)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.HtmlSlot)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.AnySlot) > 0 {
		for _, e := range m.AnySlot {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCutResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockImportMarkdown) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockImportMarkdownRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ImportPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockImportMarkdownResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.RootLinkIds) > 0 {
		for _, s := range m.RootLinkIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockImportMarkdownResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockExportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockExportResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockExportResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUpload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockUploadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.FilePath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUploadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUploadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDownload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDownloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDownloadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDownloadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetFieldsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetFieldsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetFieldsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetDetailsDetail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Value != nil {
		l = m.Value.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetDetailsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Details) > 0 {
		for _, e := range m.Details {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockSetDetailsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetDetailsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetRestrictions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetRestrictionsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Restrictions != nil {
		l = m.Restrictions.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetRestrictionsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetRestrictionsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetPage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetPageIsArchived) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetPageIsArchivedRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IsArchived {
		n += 2
	}
	return n
}

func (m *RpcBlockSetPageIsArchivedResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetPageIsArchivedResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetLatex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetLatexText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetLatexTextRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetLatexTextResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetLatexTextResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetTextText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetTextTextRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Marks != nil {
		l = m.Marks.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextTextResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextTextResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetTextColorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextColorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextColorResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetTextStyleRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	return n
}

func (m *RpcBlockSetTextStyleResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextStyleResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextChecked) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetTextCheckedRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Checked {
		n += 2
	}
	return n
}

func (m *RpcBlockSetTextCheckedResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextCheckedResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextIcon) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetTextIconRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IconImage)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IconEmoji)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextIconResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetTextIconResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetFileName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetFileNameRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetFileNameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetFileNameResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetImageName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetImageNameRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetImageNameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetImageNameResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetImageWidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetImageWidthRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Width != 0 {
		n += 1 + sovCommands(uint64(m.Width))
	}
	return n
}

func (m *RpcBlockSetImageWidthResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetImageWidthResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetVideo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetVideoName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetVideoNameRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetVideoNameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetVideoNameResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetVideoWidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetVideoWidthRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Width != 0 {
		n += 1 + sovCommands(uint64(m.Width))
	}
	return n
}

func (m *RpcBlockSetVideoWidthResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetVideoWidthResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetLinkTargetBlockId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetLinkTargetBlockIdRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetLinkTargetBlockIdResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetLinkTargetBlockIdResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockRelationSetKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockRelationSetKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRelationSetKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRelationSetKeyResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockRelationAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRelationAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRelationAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockObjectTypeSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockObjectTypeSetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ObjectTypeUrl)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockObjectTypeSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockObjectTypeSetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockBookmarkFetch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockBookmarkFetchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockBookmarkFetchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockBookmarkFetchResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockBookmarkCreateAndFetch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockBookmarkCreateAndFetchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockBookmarkCreateAndFetchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockBookmarkCreateAndFetchResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockFileCreateAndUpload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockFileCreateAndUploadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.LocalPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.FileType != 0 {
		n += 1 + sovCommands(uint64(m.FileType))
	}
	return n
}

func (m *RpcBlockFileCreateAndUploadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockFileCreateAndUploadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataview) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewViewCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewViewCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.View != nil {
		l = m.View.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewViewUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.View != nil {
		l = m.View.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewViewDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewSetPosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewViewSetPositionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockDataviewViewSetPositionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewSetPositionResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewSetActive) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewViewSetActiveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ViewId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovCommands(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	return n
}

func (m *RpcBlockDataviewViewSetActiveResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewViewSetActiveResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRecordUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Record != nil {
		l = m.Record.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRecordDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRecordCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Record != nil {
		l = m.Record.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TemplateId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Record != nil {
		l = m.Record.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRelationAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRelationUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRelationDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Option != nil {
		l = m.Option.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Option != nil {
		l = m.Option.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Option != nil {
		l = m.Option.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.OptionId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationListAvailable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewRelationListAvailableRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewRelationListAvailableResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockDataviewRelationListAvailableResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewSetSource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewSetSourceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockDataviewSetSourceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewSetSourceResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockGetMarks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockGetMarksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockGetMarksResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockGetMarksResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUndoRedoCounter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Undo != 0 {
		n += 1 + sovCommands(uint64(m.Undo))
	}
	if m.Redo != 0 {
		n += 1 + sovCommands(uint64(m.Redo))
	}
	return n
}

func (m *RpcBlockUndo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockUndoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUndoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Counters != nil {
		l = m.Counters.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUndoResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRedo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockRedoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRedoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Counters != nil {
		l = m.Counters.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockRedoResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpen) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockOpenRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockShow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockShowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockShowResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockShowResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockGetPublicWebURL) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockGetPublicWebURLRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockGetPublicWebURLResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockGetPublicWebURLResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenBreadcrumbs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockOpenBreadcrumbsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenBreadcrumbsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenBreadcrumbsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetBreadcrumbs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockSetBreadcrumbsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BreadcrumbsId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockSetBreadcrumbsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockSetBreadcrumbsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Block != nil {
		l = m.Block.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreatePage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCreatePageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	l = len(m.TemplateId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreatePageResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreatePageResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreateSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCreateSetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockCreateSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TargetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCreateSetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUnlink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockUnlinkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.BlockIds) > 0 {
		for _, s := range m.BlockIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockUnlinkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUnlinkResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockClose) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCloseRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCloseResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCloseResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceGetCurrent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceGetCurrentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceGetCurrentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.WorkspaceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceGetCurrentResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceGetAll) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceGetAllRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceGetAllResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.WorkspaceIds) > 0 {
		for _, s := range m.WorkspaceIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcWorkspaceGetAllResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.WorkspaceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceSetIsHighlighted) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceSetIsHighlightedRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IsHighlighted {
		n += 2
	}
	return n
}

func (m *RpcWorkspaceSetIsHighlightedResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceSetIsHighlightedResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceSelect) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceSelectRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.WorkspaceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceSelectResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceSelectResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWallet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWalletCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWalletCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RootPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Mnemonic)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletRecover) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWalletRecoverRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RootPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Mnemonic)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletRecoverResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletRecoverResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletConvert) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWalletConvertRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Mnemonic)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Entropy)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletConvertResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Entropy)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Mnemonic)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletConvertResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EnableDataview {
		n += 2
	}
	if m.EnableDebug {
		n += 2
	}
	if m.EnableReleaseChannelSwitch {
		n += 2
	}
	if m.EnableSpaces {
		n += 2
	}
	if m.Extra != nil {
		l = m.Extra.Size()
		n += 2 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Avatar != nil {
		n += m.Avatar.Size()
	}
	l = len(m.AlphaInviteCode)
	if l > 0 {
		n += 2 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountCreateRequestAvatarOfAvatarLocalPath) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AvatarLocalPath)
	n += 1 + l + sovCommands(uint64(l))
	return n
}
func (m *RpcAccountCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountRecover) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountRecoverRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountRecoverResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountRecoverResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountSelect) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountSelectRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RootPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountSelectResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountSelectResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountStop) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountStopRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RemoveData {
		n += 2
	}
	return n
}

func (m *RpcAccountStopResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountStopResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcLog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcLogSend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcLogSendRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Level != 0 {
		n += 1 + sovCommands(uint64(m.Level))
	}
	return n
}

func (m *RpcLogSendResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcLogSendResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcVersionGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcVersionGetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcVersionGetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Details)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcVersionGetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileOffload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileOffloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IncludeNotPinned {
		n += 2
	}
	return n
}

func (m *RpcFileOffloadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.BytesOffloaded != 0 {
		n += 1 + sovCommands(uint64(m.BytesOffloaded))
	}
	return n
}

func (m *RpcFileOffloadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcFileList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileListOffload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileListOffloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.OnlyIds) > 0 {
		for _, s := range m.OnlyIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.IncludeNotPinned {
		n += 2
	}
	return n
}

func (m *RpcFileListOffloadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.FilesOffloaded != 0 {
		n += 1 + sovCommands(uint64(m.FilesOffloaded))
	}
	if m.BytesOffloaded != 0 {
		n += 1 + sovCommands(uint64(m.BytesOffloaded))
	}
	return n
}

func (m *RpcFileListOffloadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcShutdown) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcShutdownRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcShutdownResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcShutdownResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcConfigGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcConfigGetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcConfigGetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.HomeBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ArchiveBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ProfileBlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.MarketplaceTypeId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.MarketplaceRelationId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.MarketplaceTemplateId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.DeviceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.GatewayUrl)
	if l > 0 {
		n += 2 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcConfigGetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcPing) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcPingRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovCommands(uint64(m.Index))
	}
	if m.NumberOfEventsToSend != 0 {
		n += 1 + sovCommands(uint64(m.NumberOfEventsToSend))
	}
	return n
}

func (m *RpcPingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovCommands(uint64(m.Index))
	}
	return n
}

func (m *RpcPingResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcProcess) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcProcessCancel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcProcessCancelRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcProcessCancelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcProcessCancelResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcLinkPreview) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcLinkPreviewRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcLinkPreviewResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.LinkPreview != nil {
		l = m.LinkPreview.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcLinkPreviewResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUploadFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcUploadFileRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.LocalPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovCommands(uint64(m.Type))
	}
	if m.DisableEncryption {
		n += 2
	}
	if m.Style != 0 {
		n += 1 + sovCommands(uint64(m.Style))
	}
	return n
}

func (m *RpcUploadFileResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUploadFileResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDownloadFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDownloadFileRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDownloadFileResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.LocalPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDownloadFileResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcNavigation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcNavigationListObjects) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcNavigationListObjectsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Context != 0 {
		n += 1 + sovCommands(uint64(m.Context))
	}
	l = len(m.FullText)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	if m.Offset != 0 {
		n += 1 + sovCommands(uint64(m.Offset))
	}
	return n
}

func (m *RpcNavigationListObjectsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Objects) > 0 {
		for _, e := range m.Objects {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcNavigationListObjectsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcNavigationGetObjectInfoWithLinks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcNavigationGetObjectInfoWithLinksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Context != 0 {
		n += 1 + sovCommands(uint64(m.Context))
	}
	return n
}

func (m *RpcNavigationGetObjectInfoWithLinksResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Object != nil {
		l = m.Object.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcNavigationGetObjectInfoWithLinksResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcHistoryVersions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcHistoryVersionsVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.PreviousIds) > 0 {
		for _, s := range m.PreviousIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.AuthorId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.AuthorName)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovCommands(uint64(m.Time))
	}
	if m.GroupId != 0 {
		n += 1 + sovCommands(uint64(m.GroupId))
	}
	return n
}

func (m *RpcHistoryVersionsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PageId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.LastVersionId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	return n
}

func (m *RpcHistoryVersionsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Versions) > 0 {
		for _, e := range m.Versions {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcHistoryVersionsResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistoryShow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcHistoryShowRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PageId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.VersionId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistoryShowResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.ObjectShow != nil {
		l = m.ObjectShow.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Version != nil {
		l = m.Version.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistoryShowResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistorySetVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcHistorySetVersionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PageId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.VersionId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistorySetVersionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcHistorySetVersionResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcPage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcPageCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcPageCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcPageCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.PageId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcPageCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcSetCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcSetCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TemplateId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcSetCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcSetCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeListRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeListResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.ObjectTypes) > 0 {
		for _, e := range m.ObjectTypes {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectTypeListResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObjectType != nil {
		l = m.ObjectType.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.ObjectType != nil {
		l = m.ObjectType.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeRelationAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectTypeUrl)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectTypeRelationAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectTypeRelationAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeRelationRemoveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectTypeUrl)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationRemoveResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationRemoveResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeRelationUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectTypeUrl)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectTypeRelationList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectTypeRelationListRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectTypeUrl)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.AppendRelationsFromOtherTypes {
		n += 2
	}
	return n
}

func (m *RpcObjectTypeRelationListResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectTypeRelationListResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectShareByLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectShareByLinkRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectShareByLinkResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Link)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectShareByLinkResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectAddWithObjectId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectAddWithObjectIdRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectAddWithObjectIdResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectAddWithObjectIdResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationOptionAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Option != nil {
		l = m.Option.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Option != nil {
		l = m.Option.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationOptionUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Option != nil {
		l = m.Option.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionUpdateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationOptionDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.OptionId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.ConfirmRemoveAllValuesInRecords {
		n += 2
	}
	return n
}

func (m *RpcObjectRelationOptionDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationOptionDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationListAvailable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationListAvailableRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectRelationListAvailableResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, e := range m.Relations {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectRelationListAvailableResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSearch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSearchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Filters) > 0 {
		for _, e := range m.Filters {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Sorts) > 0 {
		for _, e := range m.Sorts {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.FullText)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovCommands(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	if len(m.ObjectTypeFilter) > 0 {
		for _, s := range m.ObjectTypeFilter {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Keys) > 0 {
		for _, s := range m.Keys {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectSearchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectSearchResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectGraph) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectGraphRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Filters) > 0 {
		for _, e := range m.Filters {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	if len(m.ObjectTypeFilter) > 0 {
		for _, s := range m.ObjectTypeFilter {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectGraphNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Layout != 0 {
		n += 1 + sovCommands(uint64(m.Layout))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IconImage)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IconEmoji)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Done {
		n += 2
	}
	if m.RelationFormat != 0 {
		n += 1 + sovCommands(uint64(m.RelationFormat))
	}
	l = len(m.Snippet)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectGraphEdge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Source)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Target)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovCommands(uint64(m.Type))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IconImage)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IconEmoji)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Hidden {
		n += 2
	}
	return n
}

func (m *RpcObjectGraphResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Edges) > 0 {
		for _, e := range m.Edges {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectGraphResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSearchSubscribe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSearchSubscribeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Filters) > 0 {
		for _, e := range m.Filters {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Sorts) > 0 {
		for _, e := range m.Sorts {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	if m.Offset != 0 {
		n += 1 + sovCommands(uint64(m.Offset))
	}
	if len(m.Keys) > 0 {
		for _, s := range m.Keys {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.AfterId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.BeforeId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.IgnoreWorkspace)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.NoDepSubscription {
		n += 2
	}
	return n
}

func (m *RpcObjectSearchSubscribeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Dependencies) > 0 {
		for _, e := range m.Dependencies {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Counters != nil {
		l = m.Counters.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSearchSubscribeResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectIdsSubscribe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectIdsSubscribeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Keys) > 0 {
		for _, s := range m.Keys {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.IgnoreWorkspace)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectIdsSubscribeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if len(m.Dependencies) > 0 {
		for _, e := range m.Dependencies {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.SubId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectIdsSubscribeResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSearchUnsubscribe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSearchUnsubscribeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SubIds) > 0 {
		for _, s := range m.SubIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectSearchUnsubscribeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSearchUnsubscribeResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSetLayout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetLayoutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Layout != 0 {
		n += 1 + sovCommands(uint64(m.Layout))
	}
	return n
}

func (m *RpcObjectSetLayoutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSetLayoutResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSetIsFavorite) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetIsFavoriteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IsFavorite {
		n += 2
	}
	return n
}

func (m *RpcObjectSetIsFavoriteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSetIsFavoriteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSetIsArchived) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetIsArchivedRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IsArchived {
		n += 2
	}
	return n
}

func (m *RpcObjectSetIsArchivedResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectSetIsArchivedResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectFeaturedRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectFeaturedRelationAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectFeaturedRelationAddRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, s := range m.Relations {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectFeaturedRelationAddResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectFeaturedRelationAddResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectFeaturedRelationRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectFeaturedRelationRemoveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Relations) > 0 {
		for _, s := range m.Relations {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectFeaturedRelationRemoveResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectFeaturedRelationRemoveResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectToSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectToSetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectToSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.SetId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectToSetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ObjectIds) > 0 {
		for _, s := range m.ObjectIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectListDeleteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectListDeleteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectListSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListSetIsArchived) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListSetIsArchivedRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ObjectIds) > 0 {
		for _, s := range m.ObjectIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.IsArchived {
		n += 2
	}
	return n
}

func (m *RpcObjectListSetIsArchivedResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectListSetIsArchivedResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectListSetIsFavorite) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListSetIsFavoriteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ObjectIds) > 0 {
		for _, s := range m.ObjectIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.IsFavorite {
		n += 2
	}
	return n
}

func (m *RpcObjectListSetIsFavoriteResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectListSetIsFavoriteResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.DocIds) > 0 {
		for _, s := range m.DocIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.Format != 0 {
		n += 1 + sovCommands(uint64(m.Format))
	}
	if m.Zip {
		n += 2
	}
	if m.IncludeNested {
		n += 2
	}
	if m.IncludeFiles {
		n += 2
	}
	return n
}

func (m *RpcExportResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Succeed != 0 {
		n += 1 + sovCommands(uint64(m.Succeed))
	}
	return n
}

func (m *RpcExportResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportWorkspace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExportWorkspaceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.WorkspaceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportWorkspaceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportWorkspaceResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportTemplates) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExportTemplatesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportTemplatesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportTemplatesResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportLocalstore) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcExportLocalstoreRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.DocIds) > 0 {
		for _, s := range m.DocIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcExportLocalstoreResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcExportLocalstoreResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMakeTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcMakeTemplateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMakeTemplateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMakeTemplateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMakeTemplateByObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcMakeTemplateByObjectTypeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ObjectType)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMakeTemplateByObjectTypeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcMakeTemplateByObjectTypeResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcCloneTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcCloneTemplateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcCloneTemplateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcCloneTemplateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectDuplicateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectDuplicateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectDuplicateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUnsplashSearch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcUnsplashSearchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Query)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	return n
}

func (m *RpcUnsplashSearchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Pictures) > 0 {
		for _, e := range m.Pictures {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcUnsplashSearchResponsePicture) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Artist)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ArtistUrl)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUnsplashSearchResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUnsplashDownload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcUnsplashDownloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PictureId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUnsplashDownloadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcUnsplashDownloadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcApplyTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcApplyTemplateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TemplateId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcApplyTemplateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcApplyTemplateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebug) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDebuglogInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Head)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.HeadDownloaded {
		n += 2
	}
	if m.TotalRecords != 0 {
		n += 1 + sovCommands(uint64(m.TotalRecords))
	}
	if m.TotalSize != 0 {
		n += 1 + sovCommands(uint64(m.TotalSize))
	}
	if m.FirstRecordTs != 0 {
		n += 1 + sovCommands(uint64(m.FirstRecordTs))
	}
	if m.FirstRecordVer != 0 {
		n += 1 + sovCommands(uint64(m.FirstRecordVer))
	}
	if m.LastRecordTs != 0 {
		n += 1 + sovCommands(uint64(m.LastRecordTs))
	}
	if m.LastRecordVer != 0 {
		n += 1 + sovCommands(uint64(m.LastRecordVer))
	}
	if m.LastPullSecAgo != 0 {
		n += 1 + sovCommands(uint64(m.LastPullSecAgo))
	}
	l = len(m.UpStatus)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.DownStatus)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebugthreadInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.LogsWithDownloadedHead != 0 {
		n += 1 + sovCommands(uint64(m.LogsWithDownloadedHead))
	}
	if m.LogsWithWholeTreeDownloaded != 0 {
		n += 1 + sovCommands(uint64(m.LogsWithWholeTreeDownloaded))
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.OwnLogHasCafeReplicator {
		n += 2
	}
	if m.CafeLastPullSecAgo != 0 {
		n += 1 + sovCommands(uint64(m.CafeLastPullSecAgo))
	}
	l = len(m.CafeUpStatus)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.CafeDownStatus)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.TotalRecords != 0 {
		n += 1 + sovCommands(uint64(m.TotalRecords))
	}
	if m.TotalSize != 0 {
		n += 1 + sovCommands(uint64(m.TotalSize))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebugSync) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDebugSyncRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RecordsTraverseLimit != 0 {
		n += 1 + sovCommands(uint64(m.RecordsTraverseLimit))
	}
	if m.SkipEmptyLogs {
		n += 2
	}
	if m.TryToDownloadRemoteRecords {
		n += 2
	}
	return n
}

func (m *RpcDebugSyncResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if len(m.Threads) > 0 {
		for _, e := range m.Threads {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.DeviceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.TotalThreads != 0 {
		n += 1 + sovCommands(uint64(m.TotalThreads))
	}
	if m.ThreadsWithoutReplInOwnLog != 0 {
		n += 1 + sovCommands(uint64(m.ThreadsWithoutReplInOwnLog))
	}
	if m.ThreadsWithoutHeadDownloaded != 0 {
		n += 1 + sovCommands(uint64(m.ThreadsWithoutHeadDownloaded))
	}
	if m.TotalRecords != 0 {
		n += 1 + sovCommands(uint64(m.TotalRecords))
	}
	if m.TotalSize != 0 {
		n += 1 + sovCommands(uint64(m.TotalSize))
	}
	return n
}

func (m *RpcDebugSyncResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebugThread) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDebugThreadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ThreadId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.SkipEmptyLogs {
		n += 2
	}
	if m.TryToDownloadRemoteRecords {
		n += 2
	}
	return n
}

func (m *RpcDebugThreadResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebugThreadResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebugTree) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDebugTreeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Unanonymized {
		n += 2
	}
	return n
}

func (m *RpcDebugTreeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Filename)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcDebugTreeResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcGenericErrorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcGenericErrorResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *Empty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovCommands(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCommands(x uint64) (n int) {
	return sovCommands(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Rpc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Rpc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rpc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMetrics) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Metrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metrics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMetricsSetParameters) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetParameters: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetParameters: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMetricsSetParametersRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Platform = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMetricsSetParametersResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcMetricsSetParametersResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMetricsSetParametersResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcMetricsSetParametersResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDrop) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExternalDrop: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExternalDrop: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropFiles) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Files: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Files: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropFilesRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropTargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DropTargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalFilePaths", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalFilePaths = append(m.LocalFilePaths, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropFilesResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcExternalDropFilesResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropFilesResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcExternalDropFilesResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropContent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Content: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Content: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropContentRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FocusedBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FocusedBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...)
			if m.Content == nil {
				m.Content = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropContentResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcExternalDropContentResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExternalDropContentResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcExternalDropContentResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListConvertChildrenToPages) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConvertChildrenToPages: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConvertChildrenToPages: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListConvertChildrenToPagesRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListConvertChildrenToPagesResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListConvertChildrenToPagesResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkIds = append(m.LinkIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListConvertChildrenToPagesResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListConvertChildrenToPagesResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Move: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Move: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropTargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DropTargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListMoveResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListMoveResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveToNewPage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MoveToNewPage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MoveToNewPage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveToNewPageRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropTargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DropTargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveToNewPageResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListMoveToNewPageResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListMoveToNewPageResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListMoveToNewPageResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListDuplicate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Duplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Duplicate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListDuplicateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListDuplicateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListDuplicateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListDuplicateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListDuplicateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetTextStyleResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetTextStyleResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextColor) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Color: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Color: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextColorRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextColorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetTextColorResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextColorResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetTextColorResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextMark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Mark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Mark: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextMarkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mark", 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.Mark == nil {
				m.Mark = &model.BlockContentTextMark{}
			}
			if err := m.Mark.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextMarkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetTextMarkResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetTextMarkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetTextMarkResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetBackgroundColor) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BackgroundColor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BackgroundColor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetBackgroundColorRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetBackgroundColorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetBackgroundColorResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetBackgroundColorResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetBackgroundColorResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetAlign) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Align: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Align: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetAlignRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Align", wireType)
			}
			m.Align = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Align |= model.BlockAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetAlignResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetAlignResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetAlignResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetAlignResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFields) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFieldsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockFields", 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
			}
			m.BlockFields = append(m.BlockFields, &RpcBlockListSetFieldsRequestBlockField{})
			if err := m.BlockFields[len(m.BlockFields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFieldsRequestBlockField) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockField: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockField: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", 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.Fields == nil {
				m.Fields = &types.Struct{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFieldsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetFieldsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFieldsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetFieldsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetDiv) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Div: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Div: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetDivStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetDivStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentDivStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetDivStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetDivStyleResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetDivStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetDivStyleResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFileStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFileStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentFileStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFileStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListSetFileStyleResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetFileStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListSetFileStyleResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListTurnInto) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TurnInto: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TurnInto: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListTurnIntoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListTurnIntoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockListTurnIntoResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListTurnIntoResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockListTurnIntoResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlock) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Block: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockReplace) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Replace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Replace: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockReplaceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", 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.Block == nil {
				m.Block = &model.Block{}
			}
			if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockReplaceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockReplaceResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockReplaceResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockReplaceResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateContent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateContentRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", 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.Block == nil {
				m.Block = &model.Block{}
			}
			if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateContentResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockUpdateContentResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateContentResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockUpdateContentResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSplit) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Split: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Split: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSplitRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Range == nil {
				m.Range = &model.Range{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= RpcBlockSplitRequestMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSplitResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSplitResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSplitResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSplitResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockMerge) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Merge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Merge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockMergeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FirstBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockMergeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockMergeResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockMergeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockMergeResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCopy) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Copy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Copy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCopyRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Blocks = append(m.Blocks, &model.Block{})
			if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SelectedTextRange", 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.SelectedTextRange == nil {
				m.SelectedTextRange = &model.Range{}
			}
			if err := m.SelectedTextRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCopyResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockCopyResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TextSlot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TextSlot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HtmlSlot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HtmlSlot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnySlot", 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
			}
			m.AnySlot = append(m.AnySlot, &model.Block{})
			if err := m.AnySlot[len(m.AnySlot)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCopyResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCopyResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockPaste) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Paste: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Paste: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockPasteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FocusedBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FocusedBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SelectedTextRange", 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.SelectedTextRange == nil {
				m.SelectedTextRange = &model.Range{}
			}
			if err := m.SelectedTextRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SelectedBlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SelectedBlockIds = append(m.SelectedBlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsPartOfBlock", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsPartOfBlock = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TextSlot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TextSlot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HtmlSlot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HtmlSlot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnySlot", 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
			}
			m.AnySlot = append(m.AnySlot, &model.Block{})
			if err := m.AnySlot[len(m.AnySlot)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileSlot", 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
			}
			m.FileSlot = append(m.FileSlot, &RpcBlockPasteRequestFile{})
			if err := m.FileSlot[len(m.FileSlot)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockPasteRequestFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockPasteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockPasteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CaretPosition", wireType)
			}
			m.CaretPosition = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CaretPosition |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSameBlockCaret", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSameBlockCaret = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockPasteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockPasteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCut) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Cut: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cut: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCutRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Blocks = append(m.Blocks, &model.Block{})
			if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SelectedTextRange", 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.SelectedTextRange == nil {
				m.SelectedTextRange = &model.Range{}
			}
			if err := m.SelectedTextRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCutResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockCutResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TextSlot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TextSlot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HtmlSlot", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HtmlSlot = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnySlot", 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
			}
			m.AnySlot = append(m.AnySlot, &model.Block{})
			if err := m.AnySlot[len(m.AnySlot)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCutResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCutResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockImportMarkdown) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ImportMarkdown: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ImportMarkdown: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockImportMarkdownRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImportPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImportPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockImportMarkdownResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockImportMarkdownResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootLinkIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootLinkIds = append(m.RootLinkIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockImportMarkdownResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockImportMarkdownResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockExport) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Export: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Export: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockExportRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Blocks = append(m.Blocks, &model.Block{})
			if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockExportResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockExportResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockExportResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockExportResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Upload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Upload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUploadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FilePath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUploadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockUploadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUploadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockUploadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDownload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Download: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Download: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDownloadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDownloadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDownloadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDownloadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDownloadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFields) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Fields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFieldsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", 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.Fields == nil {
				m.Fields = &types.Struct{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFieldsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetFieldsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFieldsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetFieldsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Details: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Details: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetDetailsDetail) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Detail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Detail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Value == nil {
				m.Value = &types.Value{}
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetDetailsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Details = append(m.Details, &RpcBlockSetDetailsDetail{})
			if err := m.Details[len(m.Details)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetDetailsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetDetailsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetDetailsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetDetailsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetRestrictions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Restrictions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Restrictions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetRestrictionsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Restrictions", 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.Restrictions == nil {
				m.Restrictions = &model.BlockRestrictions{}
			}
			if err := m.Restrictions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetRestrictionsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetRestrictionsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetRestrictionsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetRestrictionsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetPage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Page: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Page: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetPageIsArchived) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IsArchived: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IsArchived: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetPageIsArchivedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsArchived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsArchived = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetPageIsArchivedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetPageIsArchivedResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetPageIsArchivedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetPageIsArchivedResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLatex) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Latex: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Latex: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLatexText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLatexTextRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLatexTextResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetLatexTextResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLatexTextResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetLatexTextResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextTextRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Marks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Marks == nil {
				m.Marks = &model.BlockContentTextMarks{}
			}
			if err := m.Marks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextTextResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetTextTextResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextTextResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetTextTextResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextColor) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Color: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Color: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextColorRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextColorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetTextColorResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextColorResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetTextColorResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Style: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Style: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetTextStyleResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetTextStyleResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextChecked) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Checked: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Checked: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextCheckedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Checked = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextCheckedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetTextCheckedResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextCheckedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetTextCheckedResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextIcon) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Icon: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Icon: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextIconRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconImage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconImage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEmoji", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconEmoji = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextIconResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetTextIconResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetTextIconResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetTextIconResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFileName) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Name: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Name: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFileNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFileNameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetFileNameResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetFileNameResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetFileNameResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageName) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Name: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Name: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageNameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetImageNameResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageNameResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetImageNameResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageWidth) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Width: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Width: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageWidthRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageWidthResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetImageWidthResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetImageWidthResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetImageWidthResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoName) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Name: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Name: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoNameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetVideoNameResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoNameResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetVideoNameResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoWidth) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Width: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Width: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoWidthRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoWidthResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetVideoWidthResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetVideoWidthResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetVideoWidthResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLink) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Link: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Link: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLinkTargetBlockId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TargetBlockId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TargetBlockId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLinkTargetBlockIdRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLinkTargetBlockIdResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetLinkTargetBlockIdResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetLinkTargetBlockIdResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetLinkTargetBlockIdResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Relation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationSetKey) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationSetKeyRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationSetKeyResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockRelationSetKeyResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationSetKeyResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockRelationSetKeyResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockRelationAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRelationAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockRelationAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockObjectType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockObjectTypeSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockObjectTypeSetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockObjectTypeSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockObjectTypeSetResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockObjectTypeSetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockObjectTypeSetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Bookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bookmark: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkFetch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Fetch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fetch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkFetchRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkFetchResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockBookmarkFetchResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkFetchResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockBookmarkFetchResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkCreateAndFetch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateAndFetch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateAndFetch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkCreateAndFetchRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkCreateAndFetchResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockBookmarkCreateAndFetchResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockBookmarkCreateAndFetchResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockBookmarkCreateAndFetchResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockFileCreateAndUpload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateAndUpload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateAndUpload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockFileCreateAndUploadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileType", wireType)
			}
			m.FileType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FileType |= model.BlockContentFileType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockFileCreateAndUploadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockFileCreateAndUploadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockFileCreateAndUploadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockFileCreateAndUploadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataview) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Dataview: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Dataview: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ViewCreate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewCreate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", 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.View == nil {
				m.View = &model.BlockContentDataviewView{}
			}
			if err := m.View.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewViewCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewViewCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ViewUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.View == nil {
				m.View = &model.BlockContentDataviewView{}
			}
			if err := m.View.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewViewUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewViewUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ViewDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewViewDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewViewDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetPosition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ViewSetPosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewSetPosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetPositionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetPositionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewViewSetPositionResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetPositionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewViewSetPositionResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetActive) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ViewSetActive: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ViewSetActive: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetActiveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetActiveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewViewSetActiveResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewViewSetActiveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewViewSetActiveResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Record", 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.Record == nil {
				m.Record = &types.Struct{}
			}
			if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRecordUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRecordUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRecordDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRecordDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordCreate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordCreate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Record", 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.Record == nil {
				m.Record = &types.Struct{}
			}
			if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemplateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TemplateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRecordCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Record", 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.Record == nil {
				m.Record = &types.Struct{}
			}
			if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRecordCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationAdd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRelationAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRelationAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRelationUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRelationUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRelationDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRelationDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordRelationOptionAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordRelationOptionAdd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", 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.Option == nil {
				m.Option = &model.RelationOption{}
			}
			if err := m.Option.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRecordRelationOptionAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", 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.Option == nil {
				m.Option = &model.RelationOption{}
			}
			if err := m.Option.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRecordRelationOptionAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordRelationOptionUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordRelationOptionUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", 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.Option == nil {
				m.Option = &model.RelationOption{}
			}
			if err := m.Option.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRecordRelationOptionUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRecordRelationOptionUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RecordRelationOptionDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordRelationOptionDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OptionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRecordRelationOptionDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRecordRelationOptionDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRecordRelationOptionDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationListAvailable) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationListAvailable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationListAvailable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationListAvailableRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationListAvailableResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewRelationListAvailableResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Relations = append(m.Relations, &model.Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewRelationListAvailableResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewRelationListAvailableResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewSetSource) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetSource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetSource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewSetSourceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewSetSourceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockDataviewSetSourceResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewSetSourceResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockDataviewSetSourceResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Get: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Get: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetMarks) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Marks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Marks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetMarksRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Range == nil {
				m.Range = &model.Range{}
			}
			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetMarksResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockGetMarksResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetMarksResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockGetMarksResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUndoRedoCounter) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UndoRedoCounter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UndoRedoCounter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Undo", wireType)
			}
			m.Undo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Undo |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Redo", wireType)
			}
			m.Redo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Redo |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUndo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Undo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Undo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUndoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUndoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockUndoResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counters", 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.Counters == nil {
				m.Counters = &RpcBlockUndoRedoCounter{}
			}
			if err := m.Counters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUndoResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockUndoResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRedo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Redo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Redo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRedoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRedoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockRedoResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counters", 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.Counters == nil {
				m.Counters = &RpcBlockUndoRedoCounter{}
			}
			if err := m.Counters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockRedoResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockRedoResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpen) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Open: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Open: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockOpenResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockOpenResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockShow) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Show: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Show: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockShowRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockShowResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockShowResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockShowResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockShowResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetPublicWebURL) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetPublicWebURL: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPublicWebURL: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetPublicWebURLRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetPublicWebURLResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockGetPublicWebURLResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockGetPublicWebURLResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockGetPublicWebURLResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenBreadcrumbs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OpenBreadcrumbs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenBreadcrumbs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenBreadcrumbsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenBreadcrumbsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockOpenBreadcrumbsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenBreadcrumbsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockOpenBreadcrumbsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetBreadcrumbs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetBreadcrumbs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetBreadcrumbs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetBreadcrumbsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BreadcrumbsId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BreadcrumbsId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetBreadcrumbsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockSetBreadcrumbsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockSetBreadcrumbsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockSetBreadcrumbsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", 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.Block == nil {
				m.Block = &model.Block{}
			}
			if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreatePage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreatePage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreatePage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreatePageRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemplateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TemplateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Fields == nil {
				m.Fields = &types.Struct{}
			}
			if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreatePageResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockCreatePageResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreatePageResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCreatePageResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateSetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= model.BlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockCreateSetResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCreateSetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCreateSetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUnlink) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Unlink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Unlink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUnlinkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockIds = append(m.BlockIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUnlinkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockUnlinkResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUnlinkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockUnlinkResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockClose) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Close: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Close: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCloseRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCloseResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcBlockCloseResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCloseResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCloseResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspace) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Workspace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Workspace: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetCurrent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetCurrent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetCurrent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetCurrentRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetCurrentResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWorkspaceGetCurrentResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkspaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkspaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetCurrentResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWorkspaceGetCurrentResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetAll) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetAll: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetAll: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetAllRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetAllResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWorkspaceGetAllResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkspaceIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkspaceIds = append(m.WorkspaceIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceGetAllResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWorkspaceGetAllResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWorkspaceCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkspaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkspaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWorkspaceCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSetIsHighlighted) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetIsHighlighted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetIsHighlighted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSetIsHighlightedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsHighlighted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsHighlighted = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSetIsHighlightedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWorkspaceSetIsHighlightedResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSetIsHighlightedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWorkspaceSetIsHighlightedResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSelect) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Select: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Select: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSelectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkspaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkspaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSelectResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWorkspaceSelectResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceSelectResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWorkspaceSelectResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWallet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Wallet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Wallet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWalletCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mnemonic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mnemonic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWalletCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletRecover) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Recover: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Recover: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletRecoverRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mnemonic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mnemonic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletRecoverResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWalletRecoverResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletRecoverResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWalletRecoverResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletConvert) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Convert: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Convert: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletConvertRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mnemonic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mnemonic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entropy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entropy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletConvertResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcWalletConvertResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entropy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entropy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mnemonic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mnemonic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletConvertResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcWalletConvertResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccount) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Account: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Account: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableDataview", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableDataview = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableDebug", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableDebug = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableReleaseChannelSwitch", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableReleaseChannelSwitch = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableSpaces", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableSpaces = bool(v != 0)
		case 100:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Extra == nil {
				m.Extra = &types.Struct{}
			}
			if err := m.Extra.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvatarLocalPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Avatar = &RpcAccountCreateRequestAvatarOfAvatarLocalPath{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlphaInviteCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AlphaInviteCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcAccountCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Account == nil {
				m.Account = &model.Account{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Config == nil {
				m.Config = &RpcAccountConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcAccountCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountRecover) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Recover: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Recover: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountRecoverRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountRecoverResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcAccountRecoverResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountRecoverResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcAccountRecoverResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountSelect) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Select: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Select: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountSelectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			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 RootPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountSelectResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcAccountSelectResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Account == nil {
				m.Account = &model.Account{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Config == nil {
				m.Config = &RpcAccountConfig{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountSelectResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcAccountSelectResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountStop) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Stop: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Stop: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountStopRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveData", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RemoveData = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountStopResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcAccountStopResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountStopResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcAccountStopResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLog) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Log: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Log: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLogSend) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Send: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Send: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLogSendRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			m.Level = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Level |= RpcLogSendRequestLevel(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLogSendResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcLogSendResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLogSendResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcLogSendResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Version: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Get: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Get: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcVersionGetResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Details = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcVersionGetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: File: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileOffload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Offload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Offload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileOffloadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			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 IncludeNotPinned", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeNotPinned = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileOffloadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcFileOffloadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesOffloaded", wireType)
			}
			m.BytesOffloaded = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesOffloaded |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileOffloadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcFileOffloadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FileList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileListOffload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Offload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Offload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileListOffloadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnlyIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OnlyIds = append(m.OnlyIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeNotPinned", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeNotPinned = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileListOffloadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcFileListOffloadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilesOffloaded", wireType)
			}
			m.FilesOffloaded = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FilesOffloaded |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesOffloaded", wireType)
			}
			m.BytesOffloaded = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesOffloaded |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcFileListOffloadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcFileListOffloadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcShutdown) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Shutdown: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Shutdown: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcShutdownRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcShutdownResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcShutdownResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcShutdownResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcShutdownResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcConfigGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Get: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Get: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcConfigGetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcConfigGetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcConfigGetResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HomeBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HomeBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArchiveBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ArchiveBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileBlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileBlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketplaceTypeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketplaceTypeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketplaceRelationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketplaceRelationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarketplaceTemplateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarketplaceTemplateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 101:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GatewayUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcConfigGetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcConfigGetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPing) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Ping: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ping: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPingRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfEventsToSend", wireType)
			}
			m.NumberOfEventsToSend = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumberOfEventsToSend |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPingResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcPingResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPingResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcPingResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcProcess) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Process: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Process: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcProcessCancel) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Cancel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cancel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcProcessCancelRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcProcessCancelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcProcessCancelResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcProcessCancelResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcProcessCancelResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLinkPreview) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LinkPreview: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LinkPreview: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLinkPreviewRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLinkPreviewResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcLinkPreviewResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkPreview", 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.LinkPreview == nil {
				m.LinkPreview = &model.LinkPreview{}
			}
			if err := m.LinkPreview.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcLinkPreviewResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcLinkPreviewResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUploadFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UploadFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UploadFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUploadFileRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= model.BlockContentFileType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableEncryption", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableEncryption = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			m.Style = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Style |= model.BlockContentFileStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUploadFileResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcUploadFileResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUploadFileResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcUploadFileResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDownloadFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DownloadFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DownloadFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDownloadFileRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDownloadFileResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcDownloadFileResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LocalPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDownloadFileResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcDownloadFileResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Navigation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Navigation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationListObjects) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListObjects: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListObjects: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationListObjectsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
			}
			m.Context = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Context |= RpcNavigationContext(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullText", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FullText = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationListObjectsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcNavigationListObjectsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Objects", 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
			}
			m.Objects = append(m.Objects, &model.ObjectInfo{})
			if err := m.Objects[len(m.Objects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationListObjectsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcNavigationListObjectsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationGetObjectInfoWithLinks) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetObjectInfoWithLinks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetObjectInfoWithLinks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationGetObjectInfoWithLinksRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
			}
			m.Context = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Context |= RpcNavigationContext(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationGetObjectInfoWithLinksResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcNavigationGetObjectInfoWithLinksResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Object", 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.Object == nil {
				m.Object = &model.ObjectInfoWithLinks{}
			}
			if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcNavigationGetObjectInfoWithLinksResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcNavigationGetObjectInfoWithLinksResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistory) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: History: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: History: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryVersions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Versions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Versions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryVersionsVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Version: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Version: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			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 PreviousIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousIds = append(m.PreviousIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthorName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthorName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
			}
			m.GroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryVersionsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PageId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastVersionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastVersionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryVersionsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcHistoryVersionsResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Versions", 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
			}
			m.Versions = append(m.Versions, &RpcHistoryVersionsVersion{})
			if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryVersionsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcHistoryVersionsResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryShow) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Show: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Show: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryShowRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PageId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VersionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryShowResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcHistoryShowResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectShow", 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.ObjectShow == nil {
				m.ObjectShow = &EventObjectShow{}
			}
			if err := m.ObjectShow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", 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.Version == nil {
				m.Version = &RpcHistoryVersionsVersion{}
			}
			if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistoryShowResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcHistoryShowResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistorySetVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetVersion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistorySetVersionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PageId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VersionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistorySetVersionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcHistorySetVersionResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcHistorySetVersionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcHistorySetVersionResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Page: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Page: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPageCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPageCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPageCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcPageCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PageId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcPageCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcPageCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcSetCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcSetCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", 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.Details == nil {
				m.Details = &types.Struct{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemplateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TemplateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcSetCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcSetCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcSetCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcSetCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeListRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeListResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectTypeListResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypes", 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
			}
			m.ObjectTypes = append(m.ObjectTypes, &model.ObjectType{})
			if err := m.ObjectTypes[len(m.ObjectTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeListResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectTypeListResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Create: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Create: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectType", 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.ObjectType == nil {
				m.ObjectType = &model.ObjectType{}
			}
			if err := m.ObjectType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectTypeCreateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectType", 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.ObjectType == nil {
				m.ObjectType = &model.ObjectType{}
			}
			if err := m.ObjectType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectTypeCreateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Relation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Relations = append(m.Relations, &model.Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectTypeRelationAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Relations = append(m.Relations, &model.Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectTypeRelationAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Remove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Remove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationRemoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationRemoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectTypeRelationRemoveResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationRemoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectTypeRelationRemoveResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Update: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectTypeRelationUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectTypeRelationUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationListRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppendRelationsFromOtherTypes", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AppendRelationsFromOtherTypes = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationListResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectTypeRelationListResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Relations = append(m.Relations, &model.Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectTypeRelationListResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectTypeRelationListResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Object: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Object: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectShareByLink) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ShareByLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShareByLink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectShareByLinkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectShareByLinkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: 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)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Link = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectShareByLinkResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectShareByLinkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectShareByLinkResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectAddWithObjectId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddWithObjectId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddWithObjectId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectAddWithObjectIdRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectAddWithObjectIdResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectAddWithObjectIdResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectAddWithObjectIdResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectAddWithObjectIdResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationAdd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Relation == nil {
				m.Relation = &model.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationOptionAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationOptionAdd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", 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.Option == nil {
				m.Option = &model.RelationOption{}
			}
			if err := m.Option.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationOptionAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", 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.Option == nil {
				m.Option = &model.RelationOption{}
			}
			if err := m.Option.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationOptionAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationOptionUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationOptionUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Option", 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.Option == nil {
				m.Option = &model.RelationOption{}
			}
			if err := m.Option.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationOptionUpdateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationOptionUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationOptionDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationOptionDelete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OptionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfirmRemoveAllValuesInRecords", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ConfirmRemoveAllValuesInRecords = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationOptionDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationOptionDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationOptionDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationListAvailable) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RelationListAvailable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelationListAvailable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationListAvailableRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationListAvailableResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectRelationListAvailableResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Relations = append(m.Relations, &model.Relation{})
			if err := m.Relations[len(m.Relations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectRelationListAvailableResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectRelationListAvailableResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Search: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Search: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Filters = append(m.Filters, &model.BlockContentDataviewFilter{})
			if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sorts", 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
			}
			m.Sorts = append(m.Sorts, &model.BlockContentDataviewSort{})
			if err := m.Sorts[len(m.Sorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullText", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FullText = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeFilter", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeFilter = append(m.ObjectTypeFilter, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectSearchResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Records = append(m.Records, &types.Struct{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectSearchResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectGraph) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Graph: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Graph: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectGraphRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Filters = append(m.Filters, &model.BlockContentDataviewFilter{})
			if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectTypeFilter", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectTypeFilter = append(m.ObjectTypeFilter, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectGraphNode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Layout", wireType)
			}
			m.Layout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Layout |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconImage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconImage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEmoji", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconEmoji = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Done", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Done = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationFormat", wireType)
			}
			m.RelationFormat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RelationFormat |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snippet", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Snippet = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectGraphEdge) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Edge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Edge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Target = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= RpcObjectGraphEdgeType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconImage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconImage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconEmoji", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IconEmoji = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hidden = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectGraphResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectGraphResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", 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
			}
			m.Nodes = append(m.Nodes, &RpcObjectGraphNode{})
			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Edges", 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
			}
			m.Edges = append(m.Edges, &RpcObjectGraphEdge{})
			if err := m.Edges[len(m.Edges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectGraphResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectGraphResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchSubscribe) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SearchSubscribe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SearchSubscribe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchSubscribeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filters", 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
			}
			m.Filters = append(m.Filters, &model.BlockContentDataviewFilter{})
			if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sorts", 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
			}
			m.Sorts = append(m.Sorts, &model.BlockContentDataviewSort{})
			if err := m.Sorts[len(m.Sorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AfterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AfterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BeforeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BeforeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreWorkspace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreWorkspace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoDepSubscription", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoDepSubscription = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchSubscribeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectSearchSubscribeResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Records = append(m.Records, &types.Struct{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Dependencies = append(m.Dependencies, &types.Struct{})
			if err := m.Dependencies[len(m.Dependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counters", 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.Counters == nil {
				m.Counters = &EventObjectSubscriptionCounters{}
			}
			if err := m.Counters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchSubscribeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectSearchSubscribeResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectIdsSubscribe) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IdsSubscribe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdsSubscribe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectIdsSubscribeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreWorkspace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IgnoreWorkspace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectIdsSubscribeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectIdsSubscribeResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Records = append(m.Records, &types.Struct{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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
			}
			m.Dependencies = append(m.Dependencies, &types.Struct{})
			if err := m.Dependencies[len(m.Dependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectIdsSubscribeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectIdsSubscribeResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchUnsubscribe) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SearchUnsubscribe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SearchUnsubscribe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchUnsubscribeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubIds = append(m.SubIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchUnsubscribeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectSearchUnsubscribeResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSearchUnsubscribeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectSearchUnsubscribeResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetLayout) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetLayout: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetLayout: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetLayoutRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Layout", wireType)
			}
			m.Layout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Layout |= model.ObjectTypeLayout(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetLayoutResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectSetLayoutResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetLayoutResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectSetLayoutResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsFavorite) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetIsFavorite: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetIsFavorite: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsFavoriteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFavorite", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFavorite = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsFavoriteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectSetIsFavoriteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsFavoriteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectSetIsFavoriteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsArchived) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetIsArchived: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetIsArchived: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsArchivedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsArchived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsArchived = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsArchivedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectSetIsArchivedResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectSetIsArchivedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectSetIsArchivedResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FeaturedRelation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FeaturedRelation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Add: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectFeaturedRelationAddResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectFeaturedRelationAddResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Remove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Remove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationRemoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Relations = append(m.Relations, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationRemoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectFeaturedRelationRemoveResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectFeaturedRelationRemoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectFeaturedRelationRemoveResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectToSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ToSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ToSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectToSetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectToSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectToSetResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectToSetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectToSetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Delete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Delete: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectIds = append(m.ObjectIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectListDeleteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectListDeleteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Set: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Set: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsArchived) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IsArchived: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IsArchived: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsArchivedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectIds = append(m.ObjectIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsArchived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsArchived = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsArchivedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectListSetIsArchivedResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsArchivedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectListSetIsArchivedResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsFavorite) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IsFavorite: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IsFavorite: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsFavoriteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectIds = append(m.ObjectIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFavorite", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFavorite = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsFavoriteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectListSetIsFavoriteResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectListSetIsFavoriteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectListSetIsFavoriteResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExport) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Export: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Export: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocIds = append(m.DocIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= RpcExportFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zip", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Zip = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeNested", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeNested = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeFiles", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IncludeFiles = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcExportResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Succeed", wireType)
			}
			m.Succeed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Succeed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcExportResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportWorkspace) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExportWorkspace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExportWorkspace: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportWorkspaceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkspaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WorkspaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportWorkspaceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcExportWorkspaceResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportWorkspaceResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcExportWorkspaceResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportTemplates) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExportTemplates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExportTemplates: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportTemplatesRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportTemplatesResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcExportTemplatesResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportTemplatesResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcExportTemplatesResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportLocalstore) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExportLocalstore: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExportLocalstore: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportLocalstoreRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocIds = append(m.DocIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportLocalstoreResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcExportLocalstoreResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event == nil {
				m.Event = &ResponseEvent{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcExportLocalstoreResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcExportLocalstoreResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MakeTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MakeTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcMakeTemplateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcMakeTemplateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateByObjectType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MakeTemplateByObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MakeTemplateByObjectType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateByObjectTypeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateByObjectTypeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcMakeTemplateByObjectTypeResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcMakeTemplateByObjectTypeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcMakeTemplateByObjectTypeResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcCloneTemplate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CloneTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloneTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcCloneTemplateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcCloneTemplateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcCloneTemplateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcCloneTemplateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcCloneTemplateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectDuplicate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectDuplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectDuplicate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectDuplicateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectDuplicateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcObjectDuplicateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectDuplicateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcObjectDuplicateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashSearch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UnsplashSearch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsplashSearch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashSearchRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashSearchResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcUnsplashSearchResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pictures", 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
			}
			m.Pictures = append(m.Pictures, &RpcUnsplashSearchResponsePicture{})
			if err := m.Pictures[len(m.Pictures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashSearchResponsePicture) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Picture: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Picture: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Artist", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Artist = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArtistUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ArtistUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashSearchResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcUnsplashSearchResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashDownload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UnsplashDownload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnsplashDownload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashDownloadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PictureId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PictureId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashDownloadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcUnsplashDownloadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcUnsplashDownloadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcUnsplashDownloadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcApplyTemplate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ApplyTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplyTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcApplyTemplateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemplateId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TemplateId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcApplyTemplateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcApplyTemplateResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcApplyTemplateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcApplyTemplateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebug) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Debug: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Debug: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebuglogInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: logInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: logInfo: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			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 Head", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Head = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadDownloaded", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HeadDownloaded = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRecords", wireType)
			}
			m.TotalRecords = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalRecords |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)
			}
			m.TotalSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstRecordTs", wireType)
			}
			m.FirstRecordTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstRecordTs |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstRecordVer", wireType)
			}
			m.FirstRecordVer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstRecordVer |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastRecordTs", wireType)
			}
			m.LastRecordTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastRecordTs |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastRecordVer", wireType)
			}
			m.LastRecordVer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastRecordVer |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPullSecAgo", wireType)
			}
			m.LastPullSecAgo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastPullSecAgo |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpStatus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpStatus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownStatus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DownStatus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugthreadInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: threadInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: threadInfo: 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 ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			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 LogsWithDownloadedHead", wireType)
			}
			m.LogsWithDownloadedHead = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogsWithDownloadedHead |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogsWithWholeTreeDownloaded", wireType)
			}
			m.LogsWithWholeTreeDownloaded = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogsWithWholeTreeDownloaded |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", 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
			}
			m.Logs = append(m.Logs, &RpcDebuglogInfo{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnLogHasCafeReplicator", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OwnLogHasCafeReplicator = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CafeLastPullSecAgo", wireType)
			}
			m.CafeLastPullSecAgo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CafeLastPullSecAgo |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CafeUpStatus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CafeUpStatus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CafeDownStatus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CafeDownStatus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRecords", wireType)
			}
			m.TotalRecords = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalRecords |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)
			}
			m.TotalSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugSync) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Sync: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sync: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugSyncRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordsTraverseLimit", wireType)
			}
			m.RecordsTraverseLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecordsTraverseLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipEmptyLogs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipEmptyLogs = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TryToDownloadRemoteRecords", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TryToDownloadRemoteRecords = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugSyncResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcDebugSyncResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threads", 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
			}
			m.Threads = append(m.Threads, &RpcDebugthreadInfo{})
			if err := m.Threads[len(m.Threads)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalThreads", wireType)
			}
			m.TotalThreads = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalThreads |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadsWithoutReplInOwnLog", wireType)
			}
			m.ThreadsWithoutReplInOwnLog = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ThreadsWithoutReplInOwnLog |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadsWithoutHeadDownloaded", wireType)
			}
			m.ThreadsWithoutHeadDownloaded = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ThreadsWithoutHeadDownloaded |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRecords", wireType)
			}
			m.TotalRecords = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalRecords |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)
			}
			m.TotalSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugSyncResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcDebugSyncResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugThread) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Thread: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Thread: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugThreadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ThreadId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipEmptyLogs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipEmptyLogs = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TryToDownloadRemoteRecords", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TryToDownloadRemoteRecords = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugThreadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcDebugThreadResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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.Info == nil {
				m.Info = &RpcDebugthreadInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugThreadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcDebugThreadResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugTree) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Tree: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tree: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugTreeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unanonymized", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Unanonymized = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugTreeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcDebugTreeResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filename = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcDebugTreeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcDebugTreeResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcGenericErrorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GenericErrorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenericErrorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error == nil {
				m.Error = &RpcGenericErrorResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcGenericErrorResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcGenericErrorResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Empty) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Empty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipCommands(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthCommands
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCommands
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCommands
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCommands        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCommands          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCommands = fmt.Errorf("proto: unexpected end of group")
)