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"
	descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
	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 RpcAppGetVersionResponseErrorCode int32

const (
	RpcAppGetVersionResponseError_NULL             RpcAppGetVersionResponseErrorCode = 0
	RpcAppGetVersionResponseError_UNKNOWN_ERROR    RpcAppGetVersionResponseErrorCode = 1
	RpcAppGetVersionResponseError_BAD_INPUT        RpcAppGetVersionResponseErrorCode = 2
	RpcAppGetVersionResponseError_VERSION_IS_EMPTY RpcAppGetVersionResponseErrorCode = 3
	RpcAppGetVersionResponseError_NOT_FOUND        RpcAppGetVersionResponseErrorCode = 101
	RpcAppGetVersionResponseError_TIMEOUT          RpcAppGetVersionResponseErrorCode = 102
)

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

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

func (x RpcAppGetVersionResponseErrorCode) String() string {
	return proto.EnumName(RpcAppGetVersionResponseErrorCode_name, int32(x))
}

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

type RpcAppSetDeviceStateRequestDeviceState int32

const (
	RpcAppSetDeviceStateRequest_BACKGROUND RpcAppSetDeviceStateRequestDeviceState = 0
	RpcAppSetDeviceStateRequest_FOREGROUND RpcAppSetDeviceStateRequestDeviceState = 1
)

var RpcAppSetDeviceStateRequestDeviceState_name = map[int32]string{
	0: "BACKGROUND",
	1: "FOREGROUND",
}

var RpcAppSetDeviceStateRequestDeviceState_value = map[string]int32{
	"BACKGROUND": 0,
	"FOREGROUND": 1,
}

func (x RpcAppSetDeviceStateRequestDeviceState) String() string {
	return proto.EnumName(RpcAppSetDeviceStateRequestDeviceState_name, int32(x))
}

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

type RpcAppSetDeviceStateResponseErrorCode int32

const (
	RpcAppSetDeviceStateResponseError_NULL             RpcAppSetDeviceStateResponseErrorCode = 0
	RpcAppSetDeviceStateResponseError_UNKNOWN_ERROR    RpcAppSetDeviceStateResponseErrorCode = 1
	RpcAppSetDeviceStateResponseError_BAD_INPUT        RpcAppSetDeviceStateResponseErrorCode = 2
	RpcAppSetDeviceStateResponseError_NODE_NOT_STARTED RpcAppSetDeviceStateResponseErrorCode = 101
)

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

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

func (x RpcAppSetDeviceStateResponseErrorCode) String() string {
	return proto.EnumName(RpcAppSetDeviceStateResponseErrorCode_name, int32(x))
}

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

type RpcAppShutdownResponseErrorCode int32

const (
	RpcAppShutdownResponseError_NULL             RpcAppShutdownResponseErrorCode = 0
	RpcAppShutdownResponseError_UNKNOWN_ERROR    RpcAppShutdownResponseErrorCode = 1
	RpcAppShutdownResponseError_BAD_INPUT        RpcAppShutdownResponseErrorCode = 2
	RpcAppShutdownResponseError_NODE_NOT_STARTED RpcAppShutdownResponseErrorCode = 101
)

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

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

func (x RpcAppShutdownResponseErrorCode) String() string {
	return proto.EnumName(RpcAppShutdownResponseErrorCode_name, int32(x))
}

func (RpcAppShutdownResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 0, 2, 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, 1, 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, 1, 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, 1, 2, 1, 0, 0}
}

type RpcWalletCreateSessionResponseErrorCode int32

const (
	RpcWalletCreateSessionResponseError_NULL          RpcWalletCreateSessionResponseErrorCode = 0
	RpcWalletCreateSessionResponseError_UNKNOWN_ERROR RpcWalletCreateSessionResponseErrorCode = 1
	RpcWalletCreateSessionResponseError_BAD_INPUT     RpcWalletCreateSessionResponseErrorCode = 2
)

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

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

func (x RpcWalletCreateSessionResponseErrorCode) String() string {
	return proto.EnumName(RpcWalletCreateSessionResponseErrorCode_name, int32(x))
}

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

type RpcWalletCloseSessionResponseErrorCode int32

const (
	RpcWalletCloseSessionResponseError_NULL          RpcWalletCloseSessionResponseErrorCode = 0
	RpcWalletCloseSessionResponseError_UNKNOWN_ERROR RpcWalletCloseSessionResponseErrorCode = 1
	RpcWalletCloseSessionResponseError_BAD_INPUT     RpcWalletCloseSessionResponseErrorCode = 2
)

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

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

func (x RpcWalletCloseSessionResponseErrorCode) String() string {
	return proto.EnumName(RpcWalletCloseSessionResponseErrorCode_name, int32(x))
}

func (RpcWalletCloseSessionResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 1, 4, 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_FAILED_TO_WRITE_CONFIG                   RpcAccountCreateResponseErrorCode = 105
	RpcAccountCreateResponseError_FAILED_TO_CREATE_LOCAL_REPO              RpcAccountCreateResponseErrorCode = 106
	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",
	105: "FAILED_TO_WRITE_CONFIG",
	106: "FAILED_TO_CREATE_LOCAL_REPO",
	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,
	"FAILED_TO_WRITE_CONFIG":                   105,
	"FAILED_TO_CREATE_LOCAL_REPO":              106,
	"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, 2, 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
	RpcAccountRecoverResponseError_ACCOUNT_IS_DELETED                 RpcAccountRecoverResponseErrorCode = 109
)

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",
	109: "ACCOUNT_IS_DELETED",
}

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,
	"ACCOUNT_IS_DELETED":                 109,
}

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

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

type RpcAccountDeleteResponseErrorCode int32

const (
	RpcAccountDeleteResponseError_NULL                       RpcAccountDeleteResponseErrorCode = 0
	RpcAccountDeleteResponseError_UNKNOWN_ERROR              RpcAccountDeleteResponseErrorCode = 1
	RpcAccountDeleteResponseError_BAD_INPUT                  RpcAccountDeleteResponseErrorCode = 2
	RpcAccountDeleteResponseError_ACCOUNT_IS_ALREADY_DELETED RpcAccountDeleteResponseErrorCode = 101
	RpcAccountDeleteResponseError_ACCOUNT_IS_ACTIVE          RpcAccountDeleteResponseErrorCode = 102
)

var RpcAccountDeleteResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "ACCOUNT_IS_ALREADY_DELETED",
	102: "ACCOUNT_IS_ACTIVE",
}

var RpcAccountDeleteResponseErrorCode_value = map[string]int32{
	"NULL":                       0,
	"UNKNOWN_ERROR":              1,
	"BAD_INPUT":                  2,
	"ACCOUNT_IS_ALREADY_DELETED": 101,
	"ACCOUNT_IS_ACTIVE":          102,
}

func (x RpcAccountDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountDeleteResponseErrorCode_name, int32(x))
}

func (RpcAccountDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 3, 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, 2, 4, 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, 2, 5, 1, 0, 0}
}

type RpcAccountMoveResponseErrorCode int32

const (
	RpcAccountMoveResponseError_NULL                           RpcAccountMoveResponseErrorCode = 0
	RpcAccountMoveResponseError_UNKNOWN_ERROR                  RpcAccountMoveResponseErrorCode = 1
	RpcAccountMoveResponseError_BAD_INPUT                      RpcAccountMoveResponseErrorCode = 2
	RpcAccountMoveResponseError_FAILED_TO_STOP_NODE            RpcAccountMoveResponseErrorCode = 101
	RpcAccountMoveResponseError_FAILED_TO_IDENTIFY_ACCOUNT_DIR RpcAccountMoveResponseErrorCode = 102
	RpcAccountMoveResponseError_FAILED_TO_REMOVE_ACCOUNT_DATA  RpcAccountMoveResponseErrorCode = 103
	RpcAccountMoveResponseError_FAILED_TO_CREATE_LOCAL_REPO    RpcAccountMoveResponseErrorCode = 104
	RpcAccountMoveResponseError_FAILED_TO_WRITE_CONFIG         RpcAccountMoveResponseErrorCode = 105
	RpcAccountMoveResponseError_FAILED_TO_GET_CONFIG           RpcAccountMoveResponseErrorCode = 106
)

var RpcAccountMoveResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "FAILED_TO_STOP_NODE",
	102: "FAILED_TO_IDENTIFY_ACCOUNT_DIR",
	103: "FAILED_TO_REMOVE_ACCOUNT_DATA",
	104: "FAILED_TO_CREATE_LOCAL_REPO",
	105: "FAILED_TO_WRITE_CONFIG",
	106: "FAILED_TO_GET_CONFIG",
}

var RpcAccountMoveResponseErrorCode_value = map[string]int32{
	"NULL":                           0,
	"UNKNOWN_ERROR":                  1,
	"BAD_INPUT":                      2,
	"FAILED_TO_STOP_NODE":            101,
	"FAILED_TO_IDENTIFY_ACCOUNT_DIR": 102,
	"FAILED_TO_REMOVE_ACCOUNT_DATA":  103,
	"FAILED_TO_CREATE_LOCAL_REPO":    104,
	"FAILED_TO_WRITE_CONFIG":         105,
	"FAILED_TO_GET_CONFIG":           106,
}

func (x RpcAccountMoveResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountMoveResponseErrorCode_name, int32(x))
}

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

type RpcAccountConfigUpdateTimezones int32

const (
	RpcAccountConfigUpdate_GMT RpcAccountConfigUpdateTimezones = 0
	RpcAccountConfigUpdate_ECT RpcAccountConfigUpdateTimezones = 1
	RpcAccountConfigUpdate_EET RpcAccountConfigUpdateTimezones = 2
	RpcAccountConfigUpdate_EAT RpcAccountConfigUpdateTimezones = 3
	RpcAccountConfigUpdate_MET RpcAccountConfigUpdateTimezones = 4
	RpcAccountConfigUpdate_NET RpcAccountConfigUpdateTimezones = 5
	RpcAccountConfigUpdate_PLT RpcAccountConfigUpdateTimezones = 6
	RpcAccountConfigUpdate_IST RpcAccountConfigUpdateTimezones = 7
	RpcAccountConfigUpdate_BST RpcAccountConfigUpdateTimezones = 8
	RpcAccountConfigUpdate_VST RpcAccountConfigUpdateTimezones = 9
	RpcAccountConfigUpdate_CTT RpcAccountConfigUpdateTimezones = 10
	RpcAccountConfigUpdate_JST RpcAccountConfigUpdateTimezones = 11
	RpcAccountConfigUpdate_ACT RpcAccountConfigUpdateTimezones = 12
	RpcAccountConfigUpdate_AET RpcAccountConfigUpdateTimezones = 13
	RpcAccountConfigUpdate_SST RpcAccountConfigUpdateTimezones = 14
	RpcAccountConfigUpdate_NST RpcAccountConfigUpdateTimezones = 15
	RpcAccountConfigUpdate_MIT RpcAccountConfigUpdateTimezones = 16
	RpcAccountConfigUpdate_HST RpcAccountConfigUpdateTimezones = 17
	RpcAccountConfigUpdate_AST RpcAccountConfigUpdateTimezones = 18
	RpcAccountConfigUpdate_PST RpcAccountConfigUpdateTimezones = 19
	RpcAccountConfigUpdate_MST RpcAccountConfigUpdateTimezones = 20
	RpcAccountConfigUpdate_CST RpcAccountConfigUpdateTimezones = 21
	RpcAccountConfigUpdate_IET RpcAccountConfigUpdateTimezones = 22
	RpcAccountConfigUpdate_PRT RpcAccountConfigUpdateTimezones = 23
	RpcAccountConfigUpdate_CNT RpcAccountConfigUpdateTimezones = 24
	RpcAccountConfigUpdate_BET RpcAccountConfigUpdateTimezones = 25
	RpcAccountConfigUpdate_BRT RpcAccountConfigUpdateTimezones = 26
	RpcAccountConfigUpdate_CAT RpcAccountConfigUpdateTimezones = 27
)

var RpcAccountConfigUpdateTimezones_name = map[int32]string{
	0:  "GMT",
	1:  "ECT",
	2:  "EET",
	3:  "EAT",
	4:  "MET",
	5:  "NET",
	6:  "PLT",
	7:  "IST",
	8:  "BST",
	9:  "VST",
	10: "CTT",
	11: "JST",
	12: "ACT",
	13: "AET",
	14: "SST",
	15: "NST",
	16: "MIT",
	17: "HST",
	18: "AST",
	19: "PST",
	20: "MST",
	21: "CST",
	22: "IET",
	23: "PRT",
	24: "CNT",
	25: "BET",
	26: "BRT",
	27: "CAT",
}

var RpcAccountConfigUpdateTimezones_value = map[string]int32{
	"GMT": 0,
	"ECT": 1,
	"EET": 2,
	"EAT": 3,
	"MET": 4,
	"NET": 5,
	"PLT": 6,
	"IST": 7,
	"BST": 8,
	"VST": 9,
	"CTT": 10,
	"JST": 11,
	"ACT": 12,
	"AET": 13,
	"SST": 14,
	"NST": 15,
	"MIT": 16,
	"HST": 17,
	"AST": 18,
	"PST": 19,
	"MST": 20,
	"CST": 21,
	"IET": 22,
	"PRT": 23,
	"CNT": 24,
	"BET": 25,
	"BRT": 26,
	"CAT": 27,
}

func (x RpcAccountConfigUpdateTimezones) String() string {
	return proto.EnumName(RpcAccountConfigUpdateTimezones_name, int32(x))
}

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

type RpcAccountConfigUpdateResponseErrorCode int32

const (
	RpcAccountConfigUpdateResponseError_NULL                   RpcAccountConfigUpdateResponseErrorCode = 0
	RpcAccountConfigUpdateResponseError_UNKNOWN_ERROR          RpcAccountConfigUpdateResponseErrorCode = 1
	RpcAccountConfigUpdateResponseError_BAD_INPUT              RpcAccountConfigUpdateResponseErrorCode = 2
	RpcAccountConfigUpdateResponseError_ACCOUNT_IS_NOT_RUNNING RpcAccountConfigUpdateResponseErrorCode = 101
	RpcAccountConfigUpdateResponseError_FAILED_TO_WRITE_CONFIG RpcAccountConfigUpdateResponseErrorCode = 102
	RpcAccountConfigUpdateResponseError_FAILED_TO_GET_CONFIG   RpcAccountConfigUpdateResponseErrorCode = 103
)

var RpcAccountConfigUpdateResponseErrorCode_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "ACCOUNT_IS_NOT_RUNNING",
	102: "FAILED_TO_WRITE_CONFIG",
	103: "FAILED_TO_GET_CONFIG",
}

var RpcAccountConfigUpdateResponseErrorCode_value = map[string]int32{
	"NULL":                   0,
	"UNKNOWN_ERROR":          1,
	"BAD_INPUT":              2,
	"ACCOUNT_IS_NOT_RUNNING": 101,
	"FAILED_TO_WRITE_CONFIG": 102,
	"FAILED_TO_GET_CONFIG":   103,
}

func (x RpcAccountConfigUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcAccountConfigUpdateResponseErrorCode_name, int32(x))
}

func (RpcAccountConfigUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 2, 7, 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, 3, 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, 3, 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, 3, 2, 1, 0, 0}
}

type RpcWorkspaceObjectAddResponseErrorCode int32

const (
	RpcWorkspaceObjectAddResponseError_NULL          RpcWorkspaceObjectAddResponseErrorCode = 0
	RpcWorkspaceObjectAddResponseError_UNKNOWN_ERROR RpcWorkspaceObjectAddResponseErrorCode = 1
	RpcWorkspaceObjectAddResponseError_BAD_INPUT     RpcWorkspaceObjectAddResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceObjectAddResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceObjectAddResponseErrorCode_name, int32(x))
}

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

type RpcWorkspaceObjectListAddResponseErrorCode int32

const (
	RpcWorkspaceObjectListAddResponseError_NULL          RpcWorkspaceObjectListAddResponseErrorCode = 0
	RpcWorkspaceObjectListAddResponseError_UNKNOWN_ERROR RpcWorkspaceObjectListAddResponseErrorCode = 1
	RpcWorkspaceObjectListAddResponseError_BAD_INPUT     RpcWorkspaceObjectListAddResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceObjectListAddResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceObjectListAddResponseErrorCode_name, int32(x))
}

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

type RpcWorkspaceObjectListRemoveResponseErrorCode int32

const (
	RpcWorkspaceObjectListRemoveResponseError_NULL          RpcWorkspaceObjectListRemoveResponseErrorCode = 0
	RpcWorkspaceObjectListRemoveResponseError_UNKNOWN_ERROR RpcWorkspaceObjectListRemoveResponseErrorCode = 1
	RpcWorkspaceObjectListRemoveResponseError_BAD_INPUT     RpcWorkspaceObjectListRemoveResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceObjectListRemoveResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceObjectListRemoveResponseErrorCode_name, int32(x))
}

func (RpcWorkspaceObjectListRemoveResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 3, 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, 3, 4, 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, 3, 5, 1, 0, 0}
}

type RpcWorkspaceExportResponseErrorCode int32

const (
	RpcWorkspaceExportResponseError_NULL          RpcWorkspaceExportResponseErrorCode = 0
	RpcWorkspaceExportResponseError_UNKNOWN_ERROR RpcWorkspaceExportResponseErrorCode = 1
	RpcWorkspaceExportResponseError_BAD_INPUT     RpcWorkspaceExportResponseErrorCode = 2
)

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

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

func (x RpcWorkspaceExportResponseErrorCode) String() string {
	return proto.EnumName(RpcWorkspaceExportResponseErrorCode_name, int32(x))
}

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

type RpcObjectOpenResponseErrorCode int32

const (
	RpcObjectOpenResponseError_NULL                  RpcObjectOpenResponseErrorCode = 0
	RpcObjectOpenResponseError_UNKNOWN_ERROR         RpcObjectOpenResponseErrorCode = 1
	RpcObjectOpenResponseError_BAD_INPUT             RpcObjectOpenResponseErrorCode = 2
	RpcObjectOpenResponseError_NOT_FOUND             RpcObjectOpenResponseErrorCode = 3
	RpcObjectOpenResponseError_ANYTYPE_NEEDS_UPGRADE RpcObjectOpenResponseErrorCode = 10
)

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

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

func (x RpcObjectOpenResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectOpenResponseErrorCode_name, int32(x))
}

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

type RpcObjectCloseResponseErrorCode int32

const (
	RpcObjectCloseResponseError_NULL          RpcObjectCloseResponseErrorCode = 0
	RpcObjectCloseResponseError_UNKNOWN_ERROR RpcObjectCloseResponseErrorCode = 1
	RpcObjectCloseResponseError_BAD_INPUT     RpcObjectCloseResponseErrorCode = 2
)

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

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

func (x RpcObjectCloseResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCloseResponseErrorCode_name, int32(x))
}

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

type RpcObjectShowResponseErrorCode int32

const (
	RpcObjectShowResponseError_NULL                  RpcObjectShowResponseErrorCode = 0
	RpcObjectShowResponseError_UNKNOWN_ERROR         RpcObjectShowResponseErrorCode = 1
	RpcObjectShowResponseError_BAD_INPUT             RpcObjectShowResponseErrorCode = 2
	RpcObjectShowResponseError_NOT_FOUND             RpcObjectShowResponseErrorCode = 3
	RpcObjectShowResponseError_ANYTYPE_NEEDS_UPGRADE RpcObjectShowResponseErrorCode = 10
)

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

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

func (x RpcObjectShowResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectShowResponseErrorCode_name, int32(x))
}

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

type RpcObjectCreateResponseErrorCode int32

const (
	RpcObjectCreateResponseError_NULL          RpcObjectCreateResponseErrorCode = 0
	RpcObjectCreateResponseError_UNKNOWN_ERROR RpcObjectCreateResponseErrorCode = 1
	RpcObjectCreateResponseError_BAD_INPUT     RpcObjectCreateResponseErrorCode = 2
)

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

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

func (x RpcObjectCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCreateResponseErrorCode_name, int32(x))
}

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

type RpcObjectCreateBookmarkResponseErrorCode int32

const (
	RpcObjectCreateBookmarkResponseError_NULL          RpcObjectCreateBookmarkResponseErrorCode = 0
	RpcObjectCreateBookmarkResponseError_UNKNOWN_ERROR RpcObjectCreateBookmarkResponseErrorCode = 1
	RpcObjectCreateBookmarkResponseError_BAD_INPUT     RpcObjectCreateBookmarkResponseErrorCode = 2
)

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

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

func (x RpcObjectCreateBookmarkResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCreateBookmarkResponseErrorCode_name, int32(x))
}

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

type RpcObjectCreateRelationResponseErrorCode int32

const (
	RpcObjectCreateRelationResponseError_NULL          RpcObjectCreateRelationResponseErrorCode = 0
	RpcObjectCreateRelationResponseError_UNKNOWN_ERROR RpcObjectCreateRelationResponseErrorCode = 1
	RpcObjectCreateRelationResponseError_BAD_INPUT     RpcObjectCreateRelationResponseErrorCode = 2
)

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

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

func (x RpcObjectCreateRelationResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCreateRelationResponseErrorCode_name, int32(x))
}

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

type RpcObjectCreateRelationOptionResponseErrorCode int32

const (
	RpcObjectCreateRelationOptionResponseError_NULL          RpcObjectCreateRelationOptionResponseErrorCode = 0
	RpcObjectCreateRelationOptionResponseError_UNKNOWN_ERROR RpcObjectCreateRelationOptionResponseErrorCode = 1
	RpcObjectCreateRelationOptionResponseError_BAD_INPUT     RpcObjectCreateRelationOptionResponseErrorCode = 2
)

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

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

func (x RpcObjectCreateRelationOptionResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCreateRelationOptionResponseErrorCode_name, int32(x))
}

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

type RpcObjectCreateSetResponseErrorCode int32

const (
	RpcObjectCreateSetResponseError_NULL                    RpcObjectCreateSetResponseErrorCode = 0
	RpcObjectCreateSetResponseError_UNKNOWN_ERROR           RpcObjectCreateSetResponseErrorCode = 1
	RpcObjectCreateSetResponseError_BAD_INPUT               RpcObjectCreateSetResponseErrorCode = 2
	RpcObjectCreateSetResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectCreateSetResponseErrorCode = 3
)

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

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

func (x RpcObjectCreateSetResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCreateSetResponseErrorCode_name, int32(x))
}

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

type RpcObjectCreateObjectTypeResponseErrorCode int32

const (
	RpcObjectCreateObjectTypeResponseError_NULL                    RpcObjectCreateObjectTypeResponseErrorCode = 0
	RpcObjectCreateObjectTypeResponseError_UNKNOWN_ERROR           RpcObjectCreateObjectTypeResponseErrorCode = 1
	RpcObjectCreateObjectTypeResponseError_BAD_INPUT               RpcObjectCreateObjectTypeResponseErrorCode = 2
	RpcObjectCreateObjectTypeResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectCreateObjectTypeResponseErrorCode = 3
)

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

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

func (x RpcObjectCreateObjectTypeResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectCreateObjectTypeResponseErrorCode_name, int32(x))
}

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

type RpcObjectBookmarkFetchResponseErrorCode int32

const (
	RpcObjectBookmarkFetchResponseError_NULL          RpcObjectBookmarkFetchResponseErrorCode = 0
	RpcObjectBookmarkFetchResponseError_UNKNOWN_ERROR RpcObjectBookmarkFetchResponseErrorCode = 1
	RpcObjectBookmarkFetchResponseError_BAD_INPUT     RpcObjectBookmarkFetchResponseErrorCode = 2
)

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

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

func (x RpcObjectBookmarkFetchResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectBookmarkFetchResponseErrorCode_name, int32(x))
}

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

type RpcObjectToBookmarkResponseErrorCode int32

const (
	RpcObjectToBookmarkResponseError_NULL          RpcObjectToBookmarkResponseErrorCode = 0
	RpcObjectToBookmarkResponseError_UNKNOWN_ERROR RpcObjectToBookmarkResponseErrorCode = 1
	RpcObjectToBookmarkResponseError_BAD_INPUT     RpcObjectToBookmarkResponseErrorCode = 2
)

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

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

func (x RpcObjectToBookmarkResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectToBookmarkResponseErrorCode_name, int32(x))
}

func (RpcObjectToBookmarkResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 10, 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, 4, 11, 1, 0, 0}
}

type RpcObjectOpenBreadcrumbsResponseErrorCode int32

const (
	RpcObjectOpenBreadcrumbsResponseError_NULL          RpcObjectOpenBreadcrumbsResponseErrorCode = 0
	RpcObjectOpenBreadcrumbsResponseError_UNKNOWN_ERROR RpcObjectOpenBreadcrumbsResponseErrorCode = 1
	RpcObjectOpenBreadcrumbsResponseError_BAD_INPUT     RpcObjectOpenBreadcrumbsResponseErrorCode = 2
)

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

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

func (x RpcObjectOpenBreadcrumbsResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectOpenBreadcrumbsResponseErrorCode_name, int32(x))
}

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

type RpcObjectSetBreadcrumbsResponseErrorCode int32

const (
	RpcObjectSetBreadcrumbsResponseError_NULL          RpcObjectSetBreadcrumbsResponseErrorCode = 0
	RpcObjectSetBreadcrumbsResponseError_UNKNOWN_ERROR RpcObjectSetBreadcrumbsResponseErrorCode = 1
	RpcObjectSetBreadcrumbsResponseError_BAD_INPUT     RpcObjectSetBreadcrumbsResponseErrorCode = 2
)

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

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

func (x RpcObjectSetBreadcrumbsResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetBreadcrumbsResponseErrorCode_name, int32(x))
}

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

type RpcObjectImportMarkdownResponseErrorCode int32

const (
	RpcObjectImportMarkdownResponseError_NULL          RpcObjectImportMarkdownResponseErrorCode = 0
	RpcObjectImportMarkdownResponseError_UNKNOWN_ERROR RpcObjectImportMarkdownResponseErrorCode = 1
	RpcObjectImportMarkdownResponseError_BAD_INPUT     RpcObjectImportMarkdownResponseErrorCode = 2
)

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

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

func (x RpcObjectImportMarkdownResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectImportMarkdownResponseErrorCode_name, int32(x))
}

func (RpcObjectImportMarkdownResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 14, 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, 4, 15, 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, 4, 16, 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, 4, 17, 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, 4, 18, 1, 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, 4, 18, 2, 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, 4, 19, 1, 0, 0}
}

type RpcObjectGroupsSubscribeResponseErrorCode int32

const (
	RpcObjectGroupsSubscribeResponseError_NULL          RpcObjectGroupsSubscribeResponseErrorCode = 0
	RpcObjectGroupsSubscribeResponseError_UNKNOWN_ERROR RpcObjectGroupsSubscribeResponseErrorCode = 1
	RpcObjectGroupsSubscribeResponseError_BAD_INPUT     RpcObjectGroupsSubscribeResponseErrorCode = 2
)

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

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

func (x RpcObjectGroupsSubscribeResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectGroupsSubscribeResponseErrorCode_name, int32(x))
}

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

type RpcObjectSubscribeIdsResponseErrorCode int32

const (
	RpcObjectSubscribeIdsResponseError_NULL          RpcObjectSubscribeIdsResponseErrorCode = 0
	RpcObjectSubscribeIdsResponseError_UNKNOWN_ERROR RpcObjectSubscribeIdsResponseErrorCode = 1
	RpcObjectSubscribeIdsResponseError_BAD_INPUT     RpcObjectSubscribeIdsResponseErrorCode = 2
)

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

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

func (x RpcObjectSubscribeIdsResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSubscribeIdsResponseErrorCode_name, int32(x))
}

func (RpcObjectSubscribeIdsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 21, 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, 4, 22, 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, 4, 23, 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, 4, 24, 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, 4, 25, 1, 0, 0}
}

type RpcObjectSetObjectTypeResponseErrorCode int32

const (
	RpcObjectSetObjectTypeResponseError_NULL                    RpcObjectSetObjectTypeResponseErrorCode = 0
	RpcObjectSetObjectTypeResponseError_UNKNOWN_ERROR           RpcObjectSetObjectTypeResponseErrorCode = 1
	RpcObjectSetObjectTypeResponseError_BAD_INPUT               RpcObjectSetObjectTypeResponseErrorCode = 2
	RpcObjectSetObjectTypeResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectSetObjectTypeResponseErrorCode = 3
)

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

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

func (x RpcObjectSetObjectTypeResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetObjectTypeResponseErrorCode_name, int32(x))
}

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

type RpcObjectSetInternalFlagsResponseErrorCode int32

const (
	RpcObjectSetInternalFlagsResponseError_NULL                    RpcObjectSetInternalFlagsResponseErrorCode = 0
	RpcObjectSetInternalFlagsResponseError_UNKNOWN_ERROR           RpcObjectSetInternalFlagsResponseErrorCode = 1
	RpcObjectSetInternalFlagsResponseError_BAD_INPUT               RpcObjectSetInternalFlagsResponseErrorCode = 2
	RpcObjectSetInternalFlagsResponseError_UNKNOWN_OBJECT_TYPE_URL RpcObjectSetInternalFlagsResponseErrorCode = 3
)

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

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

func (x RpcObjectSetInternalFlagsResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetInternalFlagsResponseErrorCode_name, int32(x))
}

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

type RpcObjectSetDetailsResponseErrorCode int32

const (
	RpcObjectSetDetailsResponseError_NULL          RpcObjectSetDetailsResponseErrorCode = 0
	RpcObjectSetDetailsResponseError_UNKNOWN_ERROR RpcObjectSetDetailsResponseErrorCode = 1
	RpcObjectSetDetailsResponseError_BAD_INPUT     RpcObjectSetDetailsResponseErrorCode = 2
)

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

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

func (x RpcObjectSetDetailsResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectSetDetailsResponseErrorCode_name, int32(x))
}

func (RpcObjectSetDetailsResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 28, 2, 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, 4, 29, 1, 0, 0}
}

type RpcObjectUndoResponseErrorCode int32

const (
	RpcObjectUndoResponseError_NULL          RpcObjectUndoResponseErrorCode = 0
	RpcObjectUndoResponseError_UNKNOWN_ERROR RpcObjectUndoResponseErrorCode = 1
	RpcObjectUndoResponseError_BAD_INPUT     RpcObjectUndoResponseErrorCode = 2
	RpcObjectUndoResponseError_CAN_NOT_MOVE  RpcObjectUndoResponseErrorCode = 3
)

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

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

func (x RpcObjectUndoResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectUndoResponseErrorCode_name, int32(x))
}

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

type RpcObjectRedoResponseErrorCode int32

const (
	RpcObjectRedoResponseError_NULL          RpcObjectRedoResponseErrorCode = 0
	RpcObjectRedoResponseError_UNKNOWN_ERROR RpcObjectRedoResponseErrorCode = 1
	RpcObjectRedoResponseError_BAD_INPUT     RpcObjectRedoResponseErrorCode = 2
	RpcObjectRedoResponseError_CAN_NOT_MOVE  RpcObjectRedoResponseErrorCode = 3
)

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

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

func (x RpcObjectRedoResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRedoResponseErrorCode_name, int32(x))
}

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

type RpcObjectListDuplicateResponseErrorCode int32

const (
	RpcObjectListDuplicateResponseError_NULL          RpcObjectListDuplicateResponseErrorCode = 0
	RpcObjectListDuplicateResponseError_UNKNOWN_ERROR RpcObjectListDuplicateResponseErrorCode = 1
	RpcObjectListDuplicateResponseError_BAD_INPUT     RpcObjectListDuplicateResponseErrorCode = 2
)

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

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

func (x RpcObjectListDuplicateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectListDuplicateResponseErrorCode_name, int32(x))
}

func (RpcObjectListDuplicateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 33, 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, 4, 34, 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, 4, 35, 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, 4, 36, 1, 0, 0}
}

type RpcObjectApplyTemplateResponseErrorCode int32

const (
	RpcObjectApplyTemplateResponseError_NULL          RpcObjectApplyTemplateResponseErrorCode = 0
	RpcObjectApplyTemplateResponseError_UNKNOWN_ERROR RpcObjectApplyTemplateResponseErrorCode = 1
	RpcObjectApplyTemplateResponseError_BAD_INPUT     RpcObjectApplyTemplateResponseErrorCode = 2
)

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

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

func (x RpcObjectApplyTemplateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectApplyTemplateResponseErrorCode_name, int32(x))
}

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

type RpcObjectListExportFormat int32

const (
	RpcObjectListExport_Markdown   RpcObjectListExportFormat = 0
	RpcObjectListExport_Protobuf   RpcObjectListExportFormat = 1
	RpcObjectListExport_JSON       RpcObjectListExportFormat = 2
	RpcObjectListExport_DOT        RpcObjectListExportFormat = 3
	RpcObjectListExport_SVG        RpcObjectListExportFormat = 4
	RpcObjectListExport_GRAPH_JSON RpcObjectListExportFormat = 5
)

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

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

func (x RpcObjectListExportFormat) String() string {
	return proto.EnumName(RpcObjectListExportFormat_name, int32(x))
}

func (RpcObjectListExportFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 38, 0}
}

type RpcObjectListExportResponseErrorCode int32

const (
	RpcObjectListExportResponseError_NULL          RpcObjectListExportResponseErrorCode = 0
	RpcObjectListExportResponseError_UNKNOWN_ERROR RpcObjectListExportResponseErrorCode = 1
	RpcObjectListExportResponseError_BAD_INPUT     RpcObjectListExportResponseErrorCode = 2
)

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

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

func (x RpcObjectListExportResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectListExportResponseErrorCode_name, int32(x))
}

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

type RpcObjectImportRequestMode int32

const (
	RpcObjectImportRequest_ALL_OR_NOTHING RpcObjectImportRequestMode = 0
	RpcObjectImportRequest_IGNORE_ERRORS  RpcObjectImportRequestMode = 1
)

var RpcObjectImportRequestMode_name = map[int32]string{
	0: "ALL_OR_NOTHING",
	1: "IGNORE_ERRORS",
}

var RpcObjectImportRequestMode_value = map[string]int32{
	"ALL_OR_NOTHING": 0,
	"IGNORE_ERRORS":  1,
}

func (x RpcObjectImportRequestMode) String() string {
	return proto.EnumName(RpcObjectImportRequestMode_name, int32(x))
}

func (RpcObjectImportRequestMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 39, 0, 0}
}

type RpcObjectImportRequestType int32

const (
	RpcObjectImportRequest_Notion   RpcObjectImportRequestType = 0
	RpcObjectImportRequest_Markdown RpcObjectImportRequestType = 1
	RpcObjectImportRequest_External RpcObjectImportRequestType = 2
)

var RpcObjectImportRequestType_name = map[int32]string{
	0: "Notion",
	1: "Markdown",
	2: "External",
}

var RpcObjectImportRequestType_value = map[string]int32{
	"Notion":   0,
	"Markdown": 1,
	"External": 2,
}

func (x RpcObjectImportRequestType) String() string {
	return proto.EnumName(RpcObjectImportRequestType_name, int32(x))
}

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

type RpcObjectImportResponseErrorCode int32

const (
	RpcObjectImportResponseError_NULL           RpcObjectImportResponseErrorCode = 0
	RpcObjectImportResponseError_INTERNAL_ERROR RpcObjectImportResponseErrorCode = 1
	RpcObjectImportResponseError_UNKNOWN_ERROR  RpcObjectImportResponseErrorCode = 2
	RpcObjectImportResponseError_BAD_INPUT      RpcObjectImportResponseErrorCode = 3
)

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

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

func (x RpcObjectImportResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectImportResponseErrorCode_name, int32(x))
}

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

type RpcObjectImportNotionTokenValidateResponseErrorCode int32

const (
	RpcObjectImportNotionTokenValidateResponseError_NULL           RpcObjectImportNotionTokenValidateResponseErrorCode = 0
	RpcObjectImportNotionTokenValidateResponseError_INTERNAL_ERROR RpcObjectImportNotionTokenValidateResponseErrorCode = 1
	RpcObjectImportNotionTokenValidateResponseError_UNAUTHORIZED   RpcObjectImportNotionTokenValidateResponseErrorCode = 2
	RpcObjectImportNotionTokenValidateResponseError_UNKNOWN_ERROR  RpcObjectImportNotionTokenValidateResponseErrorCode = 3
	RpcObjectImportNotionTokenValidateResponseError_BAD_INPUT      RpcObjectImportNotionTokenValidateResponseErrorCode = 4
)

var RpcObjectImportNotionTokenValidateResponseErrorCode_name = map[int32]string{
	0: "NULL",
	1: "INTERNAL_ERROR",
	2: "UNAUTHORIZED",
	3: "UNKNOWN_ERROR",
	4: "BAD_INPUT",
}

var RpcObjectImportNotionTokenValidateResponseErrorCode_value = map[string]int32{
	"NULL":           0,
	"INTERNAL_ERROR": 1,
	"UNAUTHORIZED":   2,
	"UNKNOWN_ERROR":  3,
	"BAD_INPUT":      4,
}

func (x RpcObjectImportNotionTokenValidateResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectImportNotionTokenValidateResponseErrorCode_name, int32(x))
}

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

type RpcObjectImportListResponseErrorCode int32

const (
	RpcObjectImportListResponseError_NULL           RpcObjectImportListResponseErrorCode = 0
	RpcObjectImportListResponseError_INTERNAL_ERROR RpcObjectImportListResponseErrorCode = 1
	RpcObjectImportListResponseError_UNKNOWN_ERROR  RpcObjectImportListResponseErrorCode = 2
	RpcObjectImportListResponseError_BAD_INPUT      RpcObjectImportListResponseErrorCode = 3
)

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

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

func (x RpcObjectImportListResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectImportListResponseErrorCode_name, int32(x))
}

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

type RpcObjectImportListImportResponseType int32

const (
	RpcObjectImportListImportResponse_Notion   RpcObjectImportListImportResponseType = 0
	RpcObjectImportListImportResponse_Markdown RpcObjectImportListImportResponseType = 1
)

var RpcObjectImportListImportResponseType_name = map[int32]string{
	0: "Notion",
	1: "Markdown",
}

var RpcObjectImportListImportResponseType_value = map[string]int32{
	"Notion":   0,
	"Markdown": 1,
}

func (x RpcObjectImportListImportResponseType) String() string {
	return proto.EnumName(RpcObjectImportListImportResponseType_name, int32(x))
}

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

type RpcObjectRelationAddResponseErrorCode int32

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

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

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

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

func (RpcObjectRelationAddResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 0, 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, 5, 1, 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, 5, 2, 1, 0, 0}
}

type RpcObjectRelationAddFeaturedResponseErrorCode int32

const (
	RpcObjectRelationAddFeaturedResponseError_NULL          RpcObjectRelationAddFeaturedResponseErrorCode = 0
	RpcObjectRelationAddFeaturedResponseError_UNKNOWN_ERROR RpcObjectRelationAddFeaturedResponseErrorCode = 1
	RpcObjectRelationAddFeaturedResponseError_BAD_INPUT     RpcObjectRelationAddFeaturedResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationAddFeaturedResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationAddFeaturedResponseErrorCode_name, int32(x))
}

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

type RpcObjectRelationRemoveFeaturedResponseErrorCode int32

const (
	RpcObjectRelationRemoveFeaturedResponseError_NULL          RpcObjectRelationRemoveFeaturedResponseErrorCode = 0
	RpcObjectRelationRemoveFeaturedResponseError_UNKNOWN_ERROR RpcObjectRelationRemoveFeaturedResponseErrorCode = 1
	RpcObjectRelationRemoveFeaturedResponseError_BAD_INPUT     RpcObjectRelationRemoveFeaturedResponseErrorCode = 2
)

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

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

func (x RpcObjectRelationRemoveFeaturedResponseErrorCode) String() string {
	return proto.EnumName(RpcObjectRelationRemoveFeaturedResponseErrorCode_name, int32(x))
}

func (RpcObjectRelationRemoveFeaturedResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 4, 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, 6, 0, 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, 6, 0, 1, 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, 6, 0, 2, 1, 0, 0}
}

type RpcRelationListRemoveOptionResponseErrorCode int32

const (
	RpcRelationListRemoveOptionResponseError_NULL                   RpcRelationListRemoveOptionResponseErrorCode = 0
	RpcRelationListRemoveOptionResponseError_UNKNOWN_ERROR          RpcRelationListRemoveOptionResponseErrorCode = 1
	RpcRelationListRemoveOptionResponseError_BAD_INPUT              RpcRelationListRemoveOptionResponseErrorCode = 2
	RpcRelationListRemoveOptionResponseError_OPTION_USED_BY_OBJECTS RpcRelationListRemoveOptionResponseErrorCode = 3
)

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

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

func (x RpcRelationListRemoveOptionResponseErrorCode) String() string {
	return proto.EnumName(RpcRelationListRemoveOptionResponseErrorCode_name, int32(x))
}

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

type RpcRelationOptionsResponseErrorCode int32

const (
	RpcRelationOptionsResponseError_NULL          RpcRelationOptionsResponseErrorCode = 0
	RpcRelationOptionsResponseError_UNKNOWN_ERROR RpcRelationOptionsResponseErrorCode = 1
	RpcRelationOptionsResponseError_BAD_INPUT     RpcRelationOptionsResponseErrorCode = 2
)

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

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

func (x RpcRelationOptionsResponseErrorCode) String() string {
	return proto.EnumName(RpcRelationOptionsResponseErrorCode_name, int32(x))
}

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

type RpcHistoryGetVersionsResponseErrorCode int32

const (
	RpcHistoryGetVersionsResponseError_NULL          RpcHistoryGetVersionsResponseErrorCode = 0
	RpcHistoryGetVersionsResponseError_UNKNOWN_ERROR RpcHistoryGetVersionsResponseErrorCode = 1
	RpcHistoryGetVersionsResponseError_BAD_INPUT     RpcHistoryGetVersionsResponseErrorCode = 2
)

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

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

func (x RpcHistoryGetVersionsResponseErrorCode) String() string {
	return proto.EnumName(RpcHistoryGetVersionsResponseErrorCode_name, int32(x))
}

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

type RpcHistoryShowVersionResponseErrorCode int32

const (
	RpcHistoryShowVersionResponseError_NULL          RpcHistoryShowVersionResponseErrorCode = 0
	RpcHistoryShowVersionResponseError_UNKNOWN_ERROR RpcHistoryShowVersionResponseErrorCode = 1
	RpcHistoryShowVersionResponseError_BAD_INPUT     RpcHistoryShowVersionResponseErrorCode = 2
)

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

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

func (x RpcHistoryShowVersionResponseErrorCode) String() string {
	return proto.EnumName(RpcHistoryShowVersionResponseErrorCode_name, int32(x))
}

func (RpcHistoryShowVersionResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 2, 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, 8, 3, 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, 9, 1, 1, 0, 0}
}

type RpcFileUploadResponseErrorCode int32

const (
	RpcFileUploadResponseError_NULL          RpcFileUploadResponseErrorCode = 0
	RpcFileUploadResponseError_UNKNOWN_ERROR RpcFileUploadResponseErrorCode = 1
	RpcFileUploadResponseError_BAD_INPUT     RpcFileUploadResponseErrorCode = 2
)

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

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

func (x RpcFileUploadResponseErrorCode) String() string {
	return proto.EnumName(RpcFileUploadResponseErrorCode_name, int32(x))
}

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

type RpcFileDownloadResponseErrorCode int32

const (
	RpcFileDownloadResponseError_NULL          RpcFileDownloadResponseErrorCode = 0
	RpcFileDownloadResponseError_UNKNOWN_ERROR RpcFileDownloadResponseErrorCode = 1
	RpcFileDownloadResponseError_BAD_INPUT     RpcFileDownloadResponseErrorCode = 2
	RpcFileDownloadResponseError_NOT_FOUND     RpcFileDownloadResponseErrorCode = 3
)

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

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

func (x RpcFileDownloadResponseErrorCode) String() string {
	return proto.EnumName(RpcFileDownloadResponseErrorCode_name, int32(x))
}

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

type RpcFileDropResponseErrorCode int32

const (
	RpcFileDropResponseError_NULL          RpcFileDropResponseErrorCode = 0
	RpcFileDropResponseError_UNKNOWN_ERROR RpcFileDropResponseErrorCode = 1
	RpcFileDropResponseError_BAD_INPUT     RpcFileDropResponseErrorCode = 2
)

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

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

func (x RpcFileDropResponseErrorCode) String() string {
	return proto.EnumName(RpcFileDropResponseErrorCode_name, int32(x))
}

func (RpcFileDropResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 4, 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, 10, 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, 10, 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, 10, 1, 1, 0, 0}
}

type RpcTemplateCreateFromObjectResponseErrorCode int32

const (
	RpcTemplateCreateFromObjectResponseError_NULL          RpcTemplateCreateFromObjectResponseErrorCode = 0
	RpcTemplateCreateFromObjectResponseError_UNKNOWN_ERROR RpcTemplateCreateFromObjectResponseErrorCode = 1
	RpcTemplateCreateFromObjectResponseError_BAD_INPUT     RpcTemplateCreateFromObjectResponseErrorCode = 2
)

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

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

func (x RpcTemplateCreateFromObjectResponseErrorCode) String() string {
	return proto.EnumName(RpcTemplateCreateFromObjectResponseErrorCode_name, int32(x))
}

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

type RpcTemplateCreateFromObjectTypeResponseErrorCode int32

const (
	RpcTemplateCreateFromObjectTypeResponseError_NULL          RpcTemplateCreateFromObjectTypeResponseErrorCode = 0
	RpcTemplateCreateFromObjectTypeResponseError_UNKNOWN_ERROR RpcTemplateCreateFromObjectTypeResponseErrorCode = 1
	RpcTemplateCreateFromObjectTypeResponseError_BAD_INPUT     RpcTemplateCreateFromObjectTypeResponseErrorCode = 2
)

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

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

func (x RpcTemplateCreateFromObjectTypeResponseErrorCode) String() string {
	return proto.EnumName(RpcTemplateCreateFromObjectTypeResponseErrorCode_name, int32(x))
}

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

type RpcTemplateCloneResponseErrorCode int32

const (
	RpcTemplateCloneResponseError_NULL          RpcTemplateCloneResponseErrorCode = 0
	RpcTemplateCloneResponseError_UNKNOWN_ERROR RpcTemplateCloneResponseErrorCode = 1
	RpcTemplateCloneResponseError_BAD_INPUT     RpcTemplateCloneResponseErrorCode = 2
)

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

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

func (x RpcTemplateCloneResponseErrorCode) String() string {
	return proto.EnumName(RpcTemplateCloneResponseErrorCode_name, int32(x))
}

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

type RpcTemplateExportAllResponseErrorCode int32

const (
	RpcTemplateExportAllResponseError_NULL          RpcTemplateExportAllResponseErrorCode = 0
	RpcTemplateExportAllResponseError_UNKNOWN_ERROR RpcTemplateExportAllResponseErrorCode = 1
	RpcTemplateExportAllResponseError_BAD_INPUT     RpcTemplateExportAllResponseErrorCode = 2
)

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

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

func (x RpcTemplateExportAllResponseErrorCode) String() string {
	return proto.EnumName(RpcTemplateExportAllResponseErrorCode_name, int32(x))
}

func (RpcTemplateExportAllResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 3, 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, 12, 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, 13, 0, 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, 13, 1, 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, 14, 0, 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, 14, 1, 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, 14, 1, 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, 14, 2, 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, 14, 3, 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, 14, 4, 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, 14, 5, 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, 14, 6, 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, 14, 7, 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, 14, 8, 1, 0, 0}
}

type RpcBlockCreateWidgetResponseErrorCode int32

const (
	RpcBlockCreateWidgetResponseError_NULL          RpcBlockCreateWidgetResponseErrorCode = 0
	RpcBlockCreateWidgetResponseError_UNKNOWN_ERROR RpcBlockCreateWidgetResponseErrorCode = 1
	RpcBlockCreateWidgetResponseError_BAD_INPUT     RpcBlockCreateWidgetResponseErrorCode = 2
)

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

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

func (x RpcBlockCreateWidgetResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockCreateWidgetResponseErrorCode_name, int32(x))
}

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

type RpcBlockListDeleteResponseErrorCode int32

const (
	RpcBlockListDeleteResponseError_NULL          RpcBlockListDeleteResponseErrorCode = 0
	RpcBlockListDeleteResponseError_UNKNOWN_ERROR RpcBlockListDeleteResponseErrorCode = 1
	RpcBlockListDeleteResponseError_BAD_INPUT     RpcBlockListDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockListDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListDeleteResponseErrorCode_name, int32(x))
}

func (RpcBlockListDeleteResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 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, 14, 11, 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, 14, 12, 1, 0, 0}
}

type RpcBlockListSetVerticalAlignResponseErrorCode int32

const (
	RpcBlockListSetVerticalAlignResponseError_NULL          RpcBlockListSetVerticalAlignResponseErrorCode = 0
	RpcBlockListSetVerticalAlignResponseError_UNKNOWN_ERROR RpcBlockListSetVerticalAlignResponseErrorCode = 1
	RpcBlockListSetVerticalAlignResponseError_BAD_INPUT     RpcBlockListSetVerticalAlignResponseErrorCode = 2
)

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

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

func (x RpcBlockListSetVerticalAlignResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListSetVerticalAlignResponseErrorCode_name, int32(x))
}

func (RpcBlockListSetVerticalAlignResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 13, 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, 14, 14, 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, 14, 15, 1, 0, 0}
}

type RpcBlockListConvertToObjectsResponseErrorCode int32

const (
	RpcBlockListConvertToObjectsResponseError_NULL          RpcBlockListConvertToObjectsResponseErrorCode = 0
	RpcBlockListConvertToObjectsResponseError_UNKNOWN_ERROR RpcBlockListConvertToObjectsResponseErrorCode = 1
	RpcBlockListConvertToObjectsResponseError_BAD_INPUT     RpcBlockListConvertToObjectsResponseErrorCode = 2
)

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

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

func (x RpcBlockListConvertToObjectsResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListConvertToObjectsResponseErrorCode_name, int32(x))
}

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

type RpcBlockListMoveToExistingObjectResponseErrorCode int32

const (
	RpcBlockListMoveToExistingObjectResponseError_NULL          RpcBlockListMoveToExistingObjectResponseErrorCode = 0
	RpcBlockListMoveToExistingObjectResponseError_UNKNOWN_ERROR RpcBlockListMoveToExistingObjectResponseErrorCode = 1
	RpcBlockListMoveToExistingObjectResponseError_BAD_INPUT     RpcBlockListMoveToExistingObjectResponseErrorCode = 2
)

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

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

func (x RpcBlockListMoveToExistingObjectResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListMoveToExistingObjectResponseErrorCode_name, int32(x))
}

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

type RpcBlockListMoveToNewObjectResponseErrorCode int32

const (
	RpcBlockListMoveToNewObjectResponseError_NULL          RpcBlockListMoveToNewObjectResponseErrorCode = 0
	RpcBlockListMoveToNewObjectResponseError_UNKNOWN_ERROR RpcBlockListMoveToNewObjectResponseErrorCode = 1
	RpcBlockListMoveToNewObjectResponseError_BAD_INPUT     RpcBlockListMoveToNewObjectResponseErrorCode = 2
)

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

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

func (x RpcBlockListMoveToNewObjectResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockListMoveToNewObjectResponseErrorCode_name, int32(x))
}

func (RpcBlockListMoveToNewObjectResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 19, 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, 14, 20, 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, 14, 21, 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, 14, 22, 1, 0, 0}
}

type RpcBlockLatexSetTextResponseErrorCode int32

const (
	RpcBlockLatexSetTextResponseError_NULL          RpcBlockLatexSetTextResponseErrorCode = 0
	RpcBlockLatexSetTextResponseError_UNKNOWN_ERROR RpcBlockLatexSetTextResponseErrorCode = 1
	RpcBlockLatexSetTextResponseError_BAD_INPUT     RpcBlockLatexSetTextResponseErrorCode = 2
)

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

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

func (x RpcBlockLatexSetTextResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockLatexSetTextResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextSetTextResponseErrorCode int32

const (
	RpcBlockTextSetTextResponseError_NULL          RpcBlockTextSetTextResponseErrorCode = 0
	RpcBlockTextSetTextResponseError_UNKNOWN_ERROR RpcBlockTextSetTextResponseErrorCode = 1
	RpcBlockTextSetTextResponseError_BAD_INPUT     RpcBlockTextSetTextResponseErrorCode = 2
)

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

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

func (x RpcBlockTextSetTextResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextSetTextResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextSetColorResponseErrorCode int32

const (
	RpcBlockTextSetColorResponseError_NULL          RpcBlockTextSetColorResponseErrorCode = 0
	RpcBlockTextSetColorResponseError_UNKNOWN_ERROR RpcBlockTextSetColorResponseErrorCode = 1
	RpcBlockTextSetColorResponseError_BAD_INPUT     RpcBlockTextSetColorResponseErrorCode = 2
)

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

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

func (x RpcBlockTextSetColorResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextSetColorResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextSetMarksGetResponseErrorCode int32

const (
	RpcBlockTextSetMarksGetResponseError_NULL          RpcBlockTextSetMarksGetResponseErrorCode = 0
	RpcBlockTextSetMarksGetResponseError_UNKNOWN_ERROR RpcBlockTextSetMarksGetResponseErrorCode = 1
	RpcBlockTextSetMarksGetResponseError_BAD_INPUT     RpcBlockTextSetMarksGetResponseErrorCode = 2
)

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

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

func (x RpcBlockTextSetMarksGetResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextSetMarksGetResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextSetStyleResponseErrorCode int32

const (
	RpcBlockTextSetStyleResponseError_NULL          RpcBlockTextSetStyleResponseErrorCode = 0
	RpcBlockTextSetStyleResponseError_UNKNOWN_ERROR RpcBlockTextSetStyleResponseErrorCode = 1
	RpcBlockTextSetStyleResponseError_BAD_INPUT     RpcBlockTextSetStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockTextSetStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextSetStyleResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextSetCheckedResponseErrorCode int32

const (
	RpcBlockTextSetCheckedResponseError_NULL          RpcBlockTextSetCheckedResponseErrorCode = 0
	RpcBlockTextSetCheckedResponseError_UNKNOWN_ERROR RpcBlockTextSetCheckedResponseErrorCode = 1
	RpcBlockTextSetCheckedResponseError_BAD_INPUT     RpcBlockTextSetCheckedResponseErrorCode = 2
)

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

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

func (x RpcBlockTextSetCheckedResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextSetCheckedResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextSetIconResponseErrorCode int32

const (
	RpcBlockTextSetIconResponseError_NULL          RpcBlockTextSetIconResponseErrorCode = 0
	RpcBlockTextSetIconResponseError_UNKNOWN_ERROR RpcBlockTextSetIconResponseErrorCode = 1
	RpcBlockTextSetIconResponseError_BAD_INPUT     RpcBlockTextSetIconResponseErrorCode = 2
)

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

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

func (x RpcBlockTextSetIconResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextSetIconResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextListSetStyleResponseErrorCode int32

const (
	RpcBlockTextListSetStyleResponseError_NULL          RpcBlockTextListSetStyleResponseErrorCode = 0
	RpcBlockTextListSetStyleResponseError_UNKNOWN_ERROR RpcBlockTextListSetStyleResponseErrorCode = 1
	RpcBlockTextListSetStyleResponseError_BAD_INPUT     RpcBlockTextListSetStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockTextListSetStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextListSetStyleResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextListSetColorResponseErrorCode int32

const (
	RpcBlockTextListSetColorResponseError_NULL          RpcBlockTextListSetColorResponseErrorCode = 0
	RpcBlockTextListSetColorResponseError_UNKNOWN_ERROR RpcBlockTextListSetColorResponseErrorCode = 1
	RpcBlockTextListSetColorResponseError_BAD_INPUT     RpcBlockTextListSetColorResponseErrorCode = 2
)

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

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

func (x RpcBlockTextListSetColorResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextListSetColorResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextListSetMarkResponseErrorCode int32

const (
	RpcBlockTextListSetMarkResponseError_NULL          RpcBlockTextListSetMarkResponseErrorCode = 0
	RpcBlockTextListSetMarkResponseError_UNKNOWN_ERROR RpcBlockTextListSetMarkResponseErrorCode = 1
	RpcBlockTextListSetMarkResponseError_BAD_INPUT     RpcBlockTextListSetMarkResponseErrorCode = 2
)

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

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

func (x RpcBlockTextListSetMarkResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextListSetMarkResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextListClearStyleResponseErrorCode int32

const (
	RpcBlockTextListClearStyleResponseError_NULL          RpcBlockTextListClearStyleResponseErrorCode = 0
	RpcBlockTextListClearStyleResponseError_UNKNOWN_ERROR RpcBlockTextListClearStyleResponseErrorCode = 1
	RpcBlockTextListClearStyleResponseError_BAD_INPUT     RpcBlockTextListClearStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockTextListClearStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextListClearStyleResponseErrorCode_name, int32(x))
}

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

type RpcBlockTextListClearContentResponseErrorCode int32

const (
	RpcBlockTextListClearContentResponseError_NULL          RpcBlockTextListClearContentResponseErrorCode = 0
	RpcBlockTextListClearContentResponseError_UNKNOWN_ERROR RpcBlockTextListClearContentResponseErrorCode = 1
	RpcBlockTextListClearContentResponseError_BAD_INPUT     RpcBlockTextListClearContentResponseErrorCode = 2
)

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

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

func (x RpcBlockTextListClearContentResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTextListClearContentResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableCreateResponseErrorCode int32

const (
	RpcBlockTableCreateResponseError_NULL          RpcBlockTableCreateResponseErrorCode = 0
	RpcBlockTableCreateResponseError_UNKNOWN_ERROR RpcBlockTableCreateResponseErrorCode = 1
	RpcBlockTableCreateResponseError_BAD_INPUT     RpcBlockTableCreateResponseErrorCode = 2
)

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

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

func (x RpcBlockTableCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableCreateResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableRowCreateResponseErrorCode int32

const (
	RpcBlockTableRowCreateResponseError_NULL          RpcBlockTableRowCreateResponseErrorCode = 0
	RpcBlockTableRowCreateResponseError_UNKNOWN_ERROR RpcBlockTableRowCreateResponseErrorCode = 1
	RpcBlockTableRowCreateResponseError_BAD_INPUT     RpcBlockTableRowCreateResponseErrorCode = 2
)

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

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

func (x RpcBlockTableRowCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableRowCreateResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableRowSetHeaderResponseErrorCode int32

const (
	RpcBlockTableRowSetHeaderResponseError_NULL          RpcBlockTableRowSetHeaderResponseErrorCode = 0
	RpcBlockTableRowSetHeaderResponseError_UNKNOWN_ERROR RpcBlockTableRowSetHeaderResponseErrorCode = 1
	RpcBlockTableRowSetHeaderResponseError_BAD_INPUT     RpcBlockTableRowSetHeaderResponseErrorCode = 2
)

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

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

func (x RpcBlockTableRowSetHeaderResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableRowSetHeaderResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableRowListFillResponseErrorCode int32

const (
	RpcBlockTableRowListFillResponseError_NULL          RpcBlockTableRowListFillResponseErrorCode = 0
	RpcBlockTableRowListFillResponseError_UNKNOWN_ERROR RpcBlockTableRowListFillResponseErrorCode = 1
	RpcBlockTableRowListFillResponseError_BAD_INPUT     RpcBlockTableRowListFillResponseErrorCode = 2
)

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

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

func (x RpcBlockTableRowListFillResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableRowListFillResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableRowListCleanResponseErrorCode int32

const (
	RpcBlockTableRowListCleanResponseError_NULL          RpcBlockTableRowListCleanResponseErrorCode = 0
	RpcBlockTableRowListCleanResponseError_UNKNOWN_ERROR RpcBlockTableRowListCleanResponseErrorCode = 1
	RpcBlockTableRowListCleanResponseError_BAD_INPUT     RpcBlockTableRowListCleanResponseErrorCode = 2
)

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

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

func (x RpcBlockTableRowListCleanResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableRowListCleanResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableColumnListFillResponseErrorCode int32

const (
	RpcBlockTableColumnListFillResponseError_NULL          RpcBlockTableColumnListFillResponseErrorCode = 0
	RpcBlockTableColumnListFillResponseError_UNKNOWN_ERROR RpcBlockTableColumnListFillResponseErrorCode = 1
	RpcBlockTableColumnListFillResponseError_BAD_INPUT     RpcBlockTableColumnListFillResponseErrorCode = 2
)

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

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

func (x RpcBlockTableColumnListFillResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableColumnListFillResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableColumnCreateResponseErrorCode int32

const (
	RpcBlockTableColumnCreateResponseError_NULL          RpcBlockTableColumnCreateResponseErrorCode = 0
	RpcBlockTableColumnCreateResponseError_UNKNOWN_ERROR RpcBlockTableColumnCreateResponseErrorCode = 1
	RpcBlockTableColumnCreateResponseError_BAD_INPUT     RpcBlockTableColumnCreateResponseErrorCode = 2
)

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

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

func (x RpcBlockTableColumnCreateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableColumnCreateResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableRowDeleteResponseErrorCode int32

const (
	RpcBlockTableRowDeleteResponseError_NULL          RpcBlockTableRowDeleteResponseErrorCode = 0
	RpcBlockTableRowDeleteResponseError_UNKNOWN_ERROR RpcBlockTableRowDeleteResponseErrorCode = 1
	RpcBlockTableRowDeleteResponseError_BAD_INPUT     RpcBlockTableRowDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockTableRowDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableRowDeleteResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableColumnDeleteResponseErrorCode int32

const (
	RpcBlockTableColumnDeleteResponseError_NULL          RpcBlockTableColumnDeleteResponseErrorCode = 0
	RpcBlockTableColumnDeleteResponseError_UNKNOWN_ERROR RpcBlockTableColumnDeleteResponseErrorCode = 1
	RpcBlockTableColumnDeleteResponseError_BAD_INPUT     RpcBlockTableColumnDeleteResponseErrorCode = 2
)

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

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

func (x RpcBlockTableColumnDeleteResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableColumnDeleteResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableColumnMoveResponseErrorCode int32

const (
	RpcBlockTableColumnMoveResponseError_NULL          RpcBlockTableColumnMoveResponseErrorCode = 0
	RpcBlockTableColumnMoveResponseError_UNKNOWN_ERROR RpcBlockTableColumnMoveResponseErrorCode = 1
	RpcBlockTableColumnMoveResponseError_BAD_INPUT     RpcBlockTableColumnMoveResponseErrorCode = 2
)

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

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

func (x RpcBlockTableColumnMoveResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableColumnMoveResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableRowDuplicateResponseErrorCode int32

const (
	RpcBlockTableRowDuplicateResponseError_NULL          RpcBlockTableRowDuplicateResponseErrorCode = 0
	RpcBlockTableRowDuplicateResponseError_UNKNOWN_ERROR RpcBlockTableRowDuplicateResponseErrorCode = 1
	RpcBlockTableRowDuplicateResponseError_BAD_INPUT     RpcBlockTableRowDuplicateResponseErrorCode = 2
)

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

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

func (x RpcBlockTableRowDuplicateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableRowDuplicateResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableColumnDuplicateResponseErrorCode int32

const (
	RpcBlockTableColumnDuplicateResponseError_NULL          RpcBlockTableColumnDuplicateResponseErrorCode = 0
	RpcBlockTableColumnDuplicateResponseError_UNKNOWN_ERROR RpcBlockTableColumnDuplicateResponseErrorCode = 1
	RpcBlockTableColumnDuplicateResponseError_BAD_INPUT     RpcBlockTableColumnDuplicateResponseErrorCode = 2
)

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

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

func (x RpcBlockTableColumnDuplicateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableColumnDuplicateResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableExpandResponseErrorCode int32

const (
	RpcBlockTableExpandResponseError_NULL          RpcBlockTableExpandResponseErrorCode = 0
	RpcBlockTableExpandResponseError_UNKNOWN_ERROR RpcBlockTableExpandResponseErrorCode = 1
	RpcBlockTableExpandResponseError_BAD_INPUT     RpcBlockTableExpandResponseErrorCode = 2
)

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

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

func (x RpcBlockTableExpandResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableExpandResponseErrorCode_name, int32(x))
}

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

type RpcBlockTableSortResponseErrorCode int32

const (
	RpcBlockTableSortResponseError_NULL          RpcBlockTableSortResponseErrorCode = 0
	RpcBlockTableSortResponseError_UNKNOWN_ERROR RpcBlockTableSortResponseErrorCode = 1
	RpcBlockTableSortResponseError_BAD_INPUT     RpcBlockTableSortResponseErrorCode = 2
)

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

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

func (x RpcBlockTableSortResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockTableSortResponseErrorCode_name, int32(x))
}

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

type RpcBlockFileSetNameResponseErrorCode int32

const (
	RpcBlockFileSetNameResponseError_NULL          RpcBlockFileSetNameResponseErrorCode = 0
	RpcBlockFileSetNameResponseError_UNKNOWN_ERROR RpcBlockFileSetNameResponseErrorCode = 1
	RpcBlockFileSetNameResponseError_BAD_INPUT     RpcBlockFileSetNameResponseErrorCode = 2
)

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

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

func (x RpcBlockFileSetNameResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockFileSetNameResponseErrorCode_name, int32(x))
}

func (RpcBlockFileSetNameResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 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, 18, 1, 1, 0, 0}
}

type RpcBlockFileListSetStyleResponseErrorCode int32

const (
	RpcBlockFileListSetStyleResponseError_NULL          RpcBlockFileListSetStyleResponseErrorCode = 0
	RpcBlockFileListSetStyleResponseError_UNKNOWN_ERROR RpcBlockFileListSetStyleResponseErrorCode = 1
	RpcBlockFileListSetStyleResponseError_BAD_INPUT     RpcBlockFileListSetStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockFileListSetStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockFileListSetStyleResponseErrorCode_name, int32(x))
}

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

type RpcBlockImageSetNameResponseErrorCode int32

const (
	RpcBlockImageSetNameResponseError_NULL          RpcBlockImageSetNameResponseErrorCode = 0
	RpcBlockImageSetNameResponseError_UNKNOWN_ERROR RpcBlockImageSetNameResponseErrorCode = 1
	RpcBlockImageSetNameResponseError_BAD_INPUT     RpcBlockImageSetNameResponseErrorCode = 2
)

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

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

func (x RpcBlockImageSetNameResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockImageSetNameResponseErrorCode_name, int32(x))
}

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

type RpcBlockImageSetWidthResponseErrorCode int32

const (
	RpcBlockImageSetWidthResponseError_NULL          RpcBlockImageSetWidthResponseErrorCode = 0
	RpcBlockImageSetWidthResponseError_UNKNOWN_ERROR RpcBlockImageSetWidthResponseErrorCode = 1
	RpcBlockImageSetWidthResponseError_BAD_INPUT     RpcBlockImageSetWidthResponseErrorCode = 2
)

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

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

func (x RpcBlockImageSetWidthResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockImageSetWidthResponseErrorCode_name, int32(x))
}

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

type RpcBlockVideoSetNameResponseErrorCode int32

const (
	RpcBlockVideoSetNameResponseError_NULL          RpcBlockVideoSetNameResponseErrorCode = 0
	RpcBlockVideoSetNameResponseError_UNKNOWN_ERROR RpcBlockVideoSetNameResponseErrorCode = 1
	RpcBlockVideoSetNameResponseError_BAD_INPUT     RpcBlockVideoSetNameResponseErrorCode = 2
)

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

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

func (x RpcBlockVideoSetNameResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockVideoSetNameResponseErrorCode_name, int32(x))
}

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

type RpcBlockVideoSetWidthResponseErrorCode int32

const (
	RpcBlockVideoSetWidthResponseError_NULL          RpcBlockVideoSetWidthResponseErrorCode = 0
	RpcBlockVideoSetWidthResponseError_UNKNOWN_ERROR RpcBlockVideoSetWidthResponseErrorCode = 1
	RpcBlockVideoSetWidthResponseError_BAD_INPUT     RpcBlockVideoSetWidthResponseErrorCode = 2
)

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

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

func (x RpcBlockVideoSetWidthResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockVideoSetWidthResponseErrorCode_name, int32(x))
}

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

type RpcBlockLinkCreateWithObjectResponseErrorCode int32

const (
	RpcBlockLinkCreateWithObjectResponseError_NULL          RpcBlockLinkCreateWithObjectResponseErrorCode = 0
	RpcBlockLinkCreateWithObjectResponseError_UNKNOWN_ERROR RpcBlockLinkCreateWithObjectResponseErrorCode = 1
	RpcBlockLinkCreateWithObjectResponseError_BAD_INPUT     RpcBlockLinkCreateWithObjectResponseErrorCode = 2
)

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

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

func (x RpcBlockLinkCreateWithObjectResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockLinkCreateWithObjectResponseErrorCode_name, int32(x))
}

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

type RpcBlockLinkListSetAppearanceResponseErrorCode int32

const (
	RpcBlockLinkListSetAppearanceResponseError_NULL          RpcBlockLinkListSetAppearanceResponseErrorCode = 0
	RpcBlockLinkListSetAppearanceResponseError_UNKNOWN_ERROR RpcBlockLinkListSetAppearanceResponseErrorCode = 1
	RpcBlockLinkListSetAppearanceResponseError_BAD_INPUT     RpcBlockLinkListSetAppearanceResponseErrorCode = 2
)

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

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

func (x RpcBlockLinkListSetAppearanceResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockLinkListSetAppearanceResponseErrorCode_name, int32(x))
}

func (RpcBlockLinkListSetAppearanceResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 1, 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, 22, 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, 22, 1, 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, 23, 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, 23, 1, 1, 0, 0}
}

type RpcBlockDivListSetStyleResponseErrorCode int32

const (
	RpcBlockDivListSetStyleResponseError_NULL          RpcBlockDivListSetStyleResponseErrorCode = 0
	RpcBlockDivListSetStyleResponseError_UNKNOWN_ERROR RpcBlockDivListSetStyleResponseErrorCode = 1
	RpcBlockDivListSetStyleResponseError_BAD_INPUT     RpcBlockDivListSetStyleResponseErrorCode = 2
)

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

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

func (x RpcBlockDivListSetStyleResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDivListSetStyleResponseErrorCode_name, int32(x))
}

func (RpcBlockDivListSetStyleResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 4, 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, 25, 1, 0, 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, 25, 1, 1, 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, 25, 1, 2, 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, 25, 2, 1, 0, 0}
}

type RpcBlockDataviewGroupOrderUpdateResponseErrorCode int32

const (
	RpcBlockDataviewGroupOrderUpdateResponseError_NULL          RpcBlockDataviewGroupOrderUpdateResponseErrorCode = 0
	RpcBlockDataviewGroupOrderUpdateResponseError_UNKNOWN_ERROR RpcBlockDataviewGroupOrderUpdateResponseErrorCode = 1
	RpcBlockDataviewGroupOrderUpdateResponseError_BAD_INPUT     RpcBlockDataviewGroupOrderUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewGroupOrderUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewGroupOrderUpdateResponseErrorCode_name, int32(x))
}

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

type RpcBlockDataviewObjectOrderUpdateResponseErrorCode int32

const (
	RpcBlockDataviewObjectOrderUpdateResponseError_NULL          RpcBlockDataviewObjectOrderUpdateResponseErrorCode = 0
	RpcBlockDataviewObjectOrderUpdateResponseError_UNKNOWN_ERROR RpcBlockDataviewObjectOrderUpdateResponseErrorCode = 1
	RpcBlockDataviewObjectOrderUpdateResponseError_BAD_INPUT     RpcBlockDataviewObjectOrderUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewObjectOrderUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewObjectOrderUpdateResponseErrorCode_name, int32(x))
}

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

type RpcBlockDataviewCreateBookmarkResponseErrorCode int32

const (
	RpcBlockDataviewCreateBookmarkResponseError_NULL          RpcBlockDataviewCreateBookmarkResponseErrorCode = 0
	RpcBlockDataviewCreateBookmarkResponseError_UNKNOWN_ERROR RpcBlockDataviewCreateBookmarkResponseErrorCode = 1
	RpcBlockDataviewCreateBookmarkResponseError_BAD_INPUT     RpcBlockDataviewCreateBookmarkResponseErrorCode = 2
)

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

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

func (x RpcBlockDataviewCreateBookmarkResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockDataviewCreateBookmarkResponseErrorCode_name, int32(x))
}

func (RpcBlockDataviewCreateBookmarkResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 5, 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, 26, 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, 26, 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, 26, 4, 1, 0, 0}
}

type RpcDebugExportLocalstoreResponseErrorCode int32

const (
	RpcDebugExportLocalstoreResponseError_NULL          RpcDebugExportLocalstoreResponseErrorCode = 0
	RpcDebugExportLocalstoreResponseError_UNKNOWN_ERROR RpcDebugExportLocalstoreResponseErrorCode = 1
	RpcDebugExportLocalstoreResponseError_BAD_INPUT     RpcDebugExportLocalstoreResponseErrorCode = 2
)

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

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

func (x RpcDebugExportLocalstoreResponseErrorCode) String() string {
	return proto.EnumName(RpcDebugExportLocalstoreResponseErrorCode_name, int32(x))
}

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

type RpcDebugPingResponseErrorCode int32

const (
	RpcDebugPingResponseError_NULL          RpcDebugPingResponseErrorCode = 0
	RpcDebugPingResponseError_UNKNOWN_ERROR RpcDebugPingResponseErrorCode = 1
	RpcDebugPingResponseError_BAD_INPUT     RpcDebugPingResponseErrorCode = 2
)

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

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

func (x RpcDebugPingResponseErrorCode) String() string {
	return proto.EnumName(RpcDebugPingResponseErrorCode_name, int32(x))
}

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

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, 27, 0, 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, 28, 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, 28, 0, 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, 29, 0, 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, 30, 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 RpcApp struct {
}

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

var xxx_messageInfo_RpcApp proto.InternalMessageInfo

type RpcAppGetVersion struct {
}

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

var xxx_messageInfo_RpcAppGetVersion proto.InternalMessageInfo

type RpcAppGetVersionRequest struct {
}

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

var xxx_messageInfo_RpcAppGetVersionRequest proto.InternalMessageInfo

type RpcAppGetVersionResponse struct {
	Error   *RpcAppGetVersionResponseError `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 *RpcAppGetVersionResponse) Reset()         { *m = RpcAppGetVersionResponse{} }
func (m *RpcAppGetVersionResponse) String() string { return proto.CompactTextString(m) }
func (*RpcAppGetVersionResponse) ProtoMessage()    {}
func (*RpcAppGetVersionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 0, 0, 1}
}
func (m *RpcAppGetVersionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAppGetVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAppGetVersionResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAppGetVersionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAppGetVersionResponse.Merge(m, src)
}
func (m *RpcAppGetVersionResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcAppGetVersionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAppGetVersionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAppGetVersionResponse proto.InternalMessageInfo

func (m *RpcAppGetVersionResponse) GetError() *RpcAppGetVersionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcAppGetVersionResponse) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *RpcAppGetVersionResponse) GetDetails() string {
	if m != nil {
		return m.Details
	}
	return ""
}

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

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

var xxx_messageInfo_RpcAppGetVersionResponseError proto.InternalMessageInfo

func (m *RpcAppGetVersionResponseError) GetCode() RpcAppGetVersionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAppGetVersionResponseError_NULL
}

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

type RpcAppSetDeviceState struct {
}

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

var xxx_messageInfo_RpcAppSetDeviceState proto.InternalMessageInfo

type RpcAppSetDeviceStateRequest struct {
	DeviceState RpcAppSetDeviceStateRequestDeviceState `protobuf:"varint,1,opt,name=deviceState,proto3,enum=anytype.RpcAppSetDeviceStateRequestDeviceState" json:"deviceState,omitempty"`
}

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

var xxx_messageInfo_RpcAppSetDeviceStateRequest proto.InternalMessageInfo

func (m *RpcAppSetDeviceStateRequest) GetDeviceState() RpcAppSetDeviceStateRequestDeviceState {
	if m != nil {
		return m.DeviceState
	}
	return RpcAppSetDeviceStateRequest_BACKGROUND
}

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

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

var xxx_messageInfo_RpcAppSetDeviceStateResponse proto.InternalMessageInfo

func (m *RpcAppSetDeviceStateResponse) GetError() *RpcAppSetDeviceStateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcAppSetDeviceStateResponseError proto.InternalMessageInfo

func (m *RpcAppSetDeviceStateResponseError) GetCode() RpcAppSetDeviceStateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAppSetDeviceStateResponseError_NULL
}

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

type RpcAppShutdown struct {
}

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

var xxx_messageInfo_RpcAppShutdown proto.InternalMessageInfo

type RpcAppShutdownRequest struct {
}

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

var xxx_messageInfo_RpcAppShutdownRequest proto.InternalMessageInfo

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

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

var xxx_messageInfo_RpcAppShutdownResponse proto.InternalMessageInfo

func (m *RpcAppShutdownResponse) GetError() *RpcAppShutdownResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcAppShutdownResponseError proto.InternalMessageInfo

func (m *RpcAppShutdownResponseError) GetCode() RpcAppShutdownResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAppShutdownResponseError_NULL
}

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

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, 1}
}
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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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, 1, 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 ""
}

type RpcWalletCreateSession struct {
}

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

var xxx_messageInfo_RpcWalletCreateSession proto.InternalMessageInfo

type RpcWalletCreateSessionRequest struct {
	Mnemonic string `protobuf:"bytes,1,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"`
}

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

var xxx_messageInfo_RpcWalletCreateSessionRequest proto.InternalMessageInfo

func (m *RpcWalletCreateSessionRequest) GetMnemonic() string {
	if m != nil {
		return m.Mnemonic
	}
	return ""
}

type RpcWalletCreateSessionResponse struct {
	Error *RpcWalletCreateSessionResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Token string                               `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
}

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

var xxx_messageInfo_RpcWalletCreateSessionResponse proto.InternalMessageInfo

func (m *RpcWalletCreateSessionResponse) GetError() *RpcWalletCreateSessionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWalletCreateSessionResponse) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

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

var xxx_messageInfo_RpcWalletCreateSessionResponseError proto.InternalMessageInfo

func (m *RpcWalletCreateSessionResponseError) GetCode() RpcWalletCreateSessionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWalletCreateSessionResponseError_NULL
}

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

type RpcWalletCloseSession struct {
}

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

var xxx_messageInfo_RpcWalletCloseSession proto.InternalMessageInfo

type RpcWalletCloseSessionRequest struct {
	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
}

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

var xxx_messageInfo_RpcWalletCloseSessionRequest proto.InternalMessageInfo

func (m *RpcWalletCloseSessionRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

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

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

var xxx_messageInfo_RpcWalletCloseSessionResponse proto.InternalMessageInfo

func (m *RpcWalletCloseSessionResponse) GetError() *RpcWalletCloseSessionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcWalletCloseSessionResponseError proto.InternalMessageInfo

func (m *RpcWalletCloseSessionResponseError) GetCode() RpcWalletCloseSessionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWalletCloseSessionResponseError_NULL
}

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

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, 2}
}
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"`
	EnablePrereleaseChannel bool          `protobuf:"varint,3,opt,name=enablePrereleaseChannel,proto3" json:"enablePrereleaseChannel,omitempty"`
	EnableSpaces            bool          `protobuf:"varint,4,opt,name=enableSpaces,proto3" json:"enableSpaces,omitempty"`
	Extra                   *types.Struct `protobuf:"bytes,100,opt,name=extra,proto3" json:"extra,omitempty"`
}

func (m *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, 2, 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) GetEnablePrereleaseChannel() bool {
	if m != nil {
		return m.EnablePrereleaseChannel
	}
	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, 2, 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"`
	StorePath       string                          `protobuf:"bytes,3,opt,name=storePath,proto3" json:"storePath,omitempty"`
	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, 2, 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) GetStorePath() string {
	if m != nil {
		return m.StorePath
	}
	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, 2, 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, 2, 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, 2, 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, 2, 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, 2, 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, 2, 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 RpcAccountDelete struct {
}

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

var xxx_messageInfo_RpcAccountDelete proto.InternalMessageInfo

type RpcAccountDeleteRequest struct {
	Revert bool `protobuf:"varint,1,opt,name=revert,proto3" json:"revert,omitempty"`
}

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

var xxx_messageInfo_RpcAccountDeleteRequest proto.InternalMessageInfo

func (m *RpcAccountDeleteRequest) GetRevert() bool {
	if m != nil {
		return m.Revert
	}
	return false
}

type RpcAccountDeleteResponse struct {
	Error  *RpcAccountDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Status *model.AccountStatus           `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
}

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

var xxx_messageInfo_RpcAccountDeleteResponse proto.InternalMessageInfo

func (m *RpcAccountDeleteResponse) GetError() *RpcAccountDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcAccountDeleteResponseError proto.InternalMessageInfo

func (m *RpcAccountDeleteResponseError) GetCode() RpcAccountDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountDeleteResponseError_NULL
}

func (m *RpcAccountDeleteResponseError) 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, 2, 4}
}
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, 2, 4, 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, 2, 4, 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, 2, 4, 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, 2, 5}
}
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, 2, 5, 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, 2, 5, 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, 2, 5, 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 ""
}

type RpcAccountMove struct {
}

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

var xxx_messageInfo_RpcAccountMove proto.InternalMessageInfo

// *
// Front-end-to-middleware request to move a account to a new disk location
type RpcAccountMoveRequest struct {
	NewPath string `protobuf:"bytes,1,opt,name=newPath,proto3" json:"newPath,omitempty"`
}

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

var xxx_messageInfo_RpcAccountMoveRequest proto.InternalMessageInfo

func (m *RpcAccountMoveRequest) GetNewPath() string {
	if m != nil {
		return m.NewPath
	}
	return ""
}

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

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

var xxx_messageInfo_RpcAccountMoveResponse proto.InternalMessageInfo

func (m *RpcAccountMoveResponse) GetError() *RpcAccountMoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcAccountMoveResponseError proto.InternalMessageInfo

func (m *RpcAccountMoveResponseError) GetCode() RpcAccountMoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountMoveResponseError_NULL
}

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

type RpcAccountConfigUpdate struct {
}

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

var xxx_messageInfo_RpcAccountConfigUpdate proto.InternalMessageInfo

type RpcAccountConfigUpdateRequest struct {
	TimeZone        string `protobuf:"bytes,1,opt,name=timeZone,proto3" json:"timeZone,omitempty"`
	IPFSStorageAddr string `protobuf:"bytes,2,opt,name=IPFSStorageAddr,proto3" json:"IPFSStorageAddr,omitempty"`
}

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

var xxx_messageInfo_RpcAccountConfigUpdateRequest proto.InternalMessageInfo

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

func (m *RpcAccountConfigUpdateRequest) GetIPFSStorageAddr() string {
	if m != nil {
		return m.IPFSStorageAddr
	}
	return ""
}

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

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

var xxx_messageInfo_RpcAccountConfigUpdateResponse proto.InternalMessageInfo

func (m *RpcAccountConfigUpdateResponse) GetError() *RpcAccountConfigUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcAccountConfigUpdateResponseError proto.InternalMessageInfo

func (m *RpcAccountConfigUpdateResponseError) GetCode() RpcAccountConfigUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountConfigUpdateResponseError_NULL
}

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

type RpcAccountGetConfig struct {
}

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

var xxx_messageInfo_RpcAccountGetConfig proto.InternalMessageInfo

type RpcAccountGetConfigGet struct {
}

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

var xxx_messageInfo_RpcAccountGetConfigGet proto.InternalMessageInfo

type RpcAccountGetConfigGetRequest struct {
}

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

var xxx_messageInfo_RpcAccountGetConfigGetRequest proto.InternalMessageInfo

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, 3}
}
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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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, 3, 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 RpcWorkspaceObject struct {
}

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

var xxx_messageInfo_RpcWorkspaceObject proto.InternalMessageInfo

type RpcWorkspaceObjectAdd struct {
}

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

var xxx_messageInfo_RpcWorkspaceObjectAdd proto.InternalMessageInfo

type RpcWorkspaceObjectAddRequest struct {
	ObjectId string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,omitempty"`
}

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

var xxx_messageInfo_RpcWorkspaceObjectAddRequest proto.InternalMessageInfo

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

type RpcWorkspaceObjectAddResponse struct {
	Error    *RpcWorkspaceObjectAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                              `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Details  *types.Struct                       `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcWorkspaceObjectAddResponse proto.InternalMessageInfo

func (m *RpcWorkspaceObjectAddResponse) GetError() *RpcWorkspaceObjectAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

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

var xxx_messageInfo_RpcWorkspaceObjectAddResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceObjectAddResponseError) GetCode() RpcWorkspaceObjectAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceObjectAddResponseError_NULL
}

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

type RpcWorkspaceObjectListAdd struct {
}

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

var xxx_messageInfo_RpcWorkspaceObjectListAdd proto.InternalMessageInfo

type RpcWorkspaceObjectListAddRequest struct {
	ObjectIds []string `protobuf:"bytes,1,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
}

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

var xxx_messageInfo_RpcWorkspaceObjectListAddRequest proto.InternalMessageInfo

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

type RpcWorkspaceObjectListAddResponse struct {
	Error     *RpcWorkspaceObjectListAddResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectIds []string                                `protobuf:"bytes,2,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
}

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

var xxx_messageInfo_RpcWorkspaceObjectListAddResponse proto.InternalMessageInfo

func (m *RpcWorkspaceObjectListAddResponse) GetError() *RpcWorkspaceObjectListAddResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcWorkspaceObjectListAddResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceObjectListAddResponseError) GetCode() RpcWorkspaceObjectListAddResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceObjectListAddResponseError_NULL
}

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

type RpcWorkspaceObjectListRemove struct {
}

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

var xxx_messageInfo_RpcWorkspaceObjectListRemove proto.InternalMessageInfo

type RpcWorkspaceObjectListRemoveRequest struct {
	ObjectIds []string `protobuf:"bytes,1,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
}

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

var xxx_messageInfo_RpcWorkspaceObjectListRemoveRequest proto.InternalMessageInfo

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

type RpcWorkspaceObjectListRemoveResponse struct {
	Error *RpcWorkspaceObjectListRemoveResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Ids   []string                                   `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_RpcWorkspaceObjectListRemoveResponse proto.InternalMessageInfo

func (m *RpcWorkspaceObjectListRemoveResponse) GetError() *RpcWorkspaceObjectListRemoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcWorkspaceObjectListRemoveResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceObjectListRemoveResponseError) GetCode() RpcWorkspaceObjectListRemoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceObjectListRemoveResponseError_NULL
}

func (m *RpcWorkspaceObjectListRemoveResponseError) 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, 3, 4}
}
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, 3, 4, 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, 3, 4, 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, 3, 4, 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, 3, 5}
}
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, 3, 5, 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, 3, 5, 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, 3, 5, 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 ""
}

type RpcWorkspaceExport struct {
}

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

var xxx_messageInfo_RpcWorkspaceExport proto.InternalMessageInfo

type RpcWorkspaceExportRequest 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 *RpcWorkspaceExportRequest) Reset()         { *m = RpcWorkspaceExportRequest{} }
func (m *RpcWorkspaceExportRequest) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceExportRequest) ProtoMessage()    {}
func (*RpcWorkspaceExportRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 6, 0}
}
func (m *RpcWorkspaceExportRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceExportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceExportRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceExportRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceExportRequest.Merge(m, src)
}
func (m *RpcWorkspaceExportRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceExportRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceExportRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceExportRequest proto.InternalMessageInfo

func (m *RpcWorkspaceExportRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcWorkspaceExportRequest) GetWorkspaceId() string {
	if m != nil {
		return m.WorkspaceId
	}
	return ""
}

type RpcWorkspaceExportResponse struct {
	Error *RpcWorkspaceExportResponseError `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 *RpcWorkspaceExportResponse) Reset()         { *m = RpcWorkspaceExportResponse{} }
func (m *RpcWorkspaceExportResponse) String() string { return proto.CompactTextString(m) }
func (*RpcWorkspaceExportResponse) ProtoMessage()    {}
func (*RpcWorkspaceExportResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 3, 6, 1}
}
func (m *RpcWorkspaceExportResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcWorkspaceExportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcWorkspaceExportResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcWorkspaceExportResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcWorkspaceExportResponse.Merge(m, src)
}
func (m *RpcWorkspaceExportResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcWorkspaceExportResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcWorkspaceExportResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcWorkspaceExportResponse proto.InternalMessageInfo

func (m *RpcWorkspaceExportResponse) GetError() *RpcWorkspaceExportResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcWorkspaceExportResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcWorkspaceExportResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcWorkspaceExportResponseError proto.InternalMessageInfo

func (m *RpcWorkspaceExportResponseError) GetCode() RpcWorkspaceExportResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcWorkspaceExportResponseError_NULL
}

func (m *RpcWorkspaceExportResponseError) 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, 4}
}
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 RpcObjectOpen struct {
}

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

var xxx_messageInfo_RpcObjectOpen proto.InternalMessageInfo

type RpcObjectOpenRequest struct {
	ContextId                          string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	ObjectId                           string `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	TraceId                            string `protobuf:"bytes,3,opt,name=traceId,proto3" json:"traceId,omitempty"`
	IncludeRelationsAsDependentObjects bool   `protobuf:"varint,4,opt,name=includeRelationsAsDependentObjects,proto3" json:"includeRelationsAsDependentObjects,omitempty"`
}

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

var xxx_messageInfo_RpcObjectOpenRequest proto.InternalMessageInfo

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

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

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

func (m *RpcObjectOpenRequest) GetIncludeRelationsAsDependentObjects() bool {
	if m != nil {
		return m.IncludeRelationsAsDependentObjects
	}
	return false
}

type RpcObjectOpenResponse struct {
	Error      *RpcObjectOpenResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectView *model.ObjectView           `protobuf:"bytes,2,opt,name=objectView,proto3" json:"objectView,omitempty"`
}

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

var xxx_messageInfo_RpcObjectOpenResponse proto.InternalMessageInfo

func (m *RpcObjectOpenResponse) GetError() *RpcObjectOpenResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectOpenResponse) GetObjectView() *model.ObjectView {
	if m != nil {
		return m.ObjectView
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectOpenResponseError proto.InternalMessageInfo

func (m *RpcObjectOpenResponseError) GetCode() RpcObjectOpenResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectOpenResponseError_NULL
}

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

type RpcObjectClose struct {
}

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

var xxx_messageInfo_RpcObjectClose proto.InternalMessageInfo

type RpcObjectCloseRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	ObjectId  string `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCloseRequest proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_RpcObjectCloseResponse proto.InternalMessageInfo

func (m *RpcObjectCloseResponse) GetError() *RpcObjectCloseResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectCloseResponseError proto.InternalMessageInfo

func (m *RpcObjectCloseResponseError) GetCode() RpcObjectCloseResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCloseResponseError_NULL
}

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

type RpcObjectShow struct {
}

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

var xxx_messageInfo_RpcObjectShow proto.InternalMessageInfo

type RpcObjectShowRequest struct {
	ContextId                          string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	ObjectId                           string `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	TraceId                            string `protobuf:"bytes,3,opt,name=traceId,proto3" json:"traceId,omitempty"`
	IncludeRelationsAsDependentObjects bool   `protobuf:"varint,4,opt,name=includeRelationsAsDependentObjects,proto3" json:"includeRelationsAsDependentObjects,omitempty"`
}

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

var xxx_messageInfo_RpcObjectShowRequest proto.InternalMessageInfo

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

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

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

func (m *RpcObjectShowRequest) GetIncludeRelationsAsDependentObjects() bool {
	if m != nil {
		return m.IncludeRelationsAsDependentObjects
	}
	return false
}

type RpcObjectShowResponse struct {
	Error      *RpcObjectShowResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectView *model.ObjectView           `protobuf:"bytes,2,opt,name=objectView,proto3" json:"objectView,omitempty"`
}

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

var xxx_messageInfo_RpcObjectShowResponse proto.InternalMessageInfo

func (m *RpcObjectShowResponse) GetError() *RpcObjectShowResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectShowResponse) GetObjectView() *model.ObjectView {
	if m != nil {
		return m.ObjectView
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectShowResponseError proto.InternalMessageInfo

func (m *RpcObjectShowResponseError) GetCode() RpcObjectShowResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectShowResponseError_NULL
}

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

type RpcObjectCreate struct {
}

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

var xxx_messageInfo_RpcObjectCreate proto.InternalMessageInfo

type RpcObjectCreateRequest struct {
	Details       *types.Struct         `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
	InternalFlags []*model.InternalFlag `protobuf:"bytes,2,rep,name=internalFlags,proto3" json:"internalFlags,omitempty"`
	TemplateId    string                `protobuf:"bytes,3,opt,name=templateId,proto3" json:"templateId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateRequest proto.InternalMessageInfo

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

func (m *RpcObjectCreateRequest) GetInternalFlags() []*model.InternalFlag {
	if m != nil {
		return m.InternalFlags
	}
	return nil
}

func (m *RpcObjectCreateRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

type RpcObjectCreateResponse struct {
	Error    *RpcObjectCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                        `protobuf:"bytes,3,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Event    *ResponseEvent                `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
	Details  *types.Struct                 `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateResponse proto.InternalMessageInfo

func (m *RpcObjectCreateResponse) GetError() *RpcObjectCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcObjectCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcObjectCreateResponseError proto.InternalMessageInfo

func (m *RpcObjectCreateResponseError) GetCode() RpcObjectCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCreateResponseError_NULL
}

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

type RpcObjectCreateBookmark struct {
}

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

var xxx_messageInfo_RpcObjectCreateBookmark proto.InternalMessageInfo

type RpcObjectCreateBookmarkRequest struct {
	Details *types.Struct `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateBookmarkRequest proto.InternalMessageInfo

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

type RpcObjectCreateBookmarkResponse struct {
	Error    *RpcObjectCreateBookmarkResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                                `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Details  *types.Struct                         `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateBookmarkResponse proto.InternalMessageInfo

func (m *RpcObjectCreateBookmarkResponse) GetError() *RpcObjectCreateBookmarkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

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

var xxx_messageInfo_RpcObjectCreateBookmarkResponseError proto.InternalMessageInfo

func (m *RpcObjectCreateBookmarkResponseError) GetCode() RpcObjectCreateBookmarkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCreateBookmarkResponseError_NULL
}

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

type RpcObjectCreateRelation struct {
}

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

var xxx_messageInfo_RpcObjectCreateRelation proto.InternalMessageInfo

type RpcObjectCreateRelationRequest struct {
	Details *types.Struct `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateRelationRequest proto.InternalMessageInfo

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

type RpcObjectCreateRelationResponse struct {
	Error    *RpcObjectCreateRelationResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                                `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Key      string                                `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	Details  *types.Struct                         `protobuf:"bytes,4,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateRelationResponse proto.InternalMessageInfo

func (m *RpcObjectCreateRelationResponse) GetError() *RpcObjectCreateRelationResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

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

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

var xxx_messageInfo_RpcObjectCreateRelationResponseError proto.InternalMessageInfo

func (m *RpcObjectCreateRelationResponseError) GetCode() RpcObjectCreateRelationResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCreateRelationResponseError_NULL
}

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

type RpcObjectCreateRelationOption struct {
}

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

var xxx_messageInfo_RpcObjectCreateRelationOption proto.InternalMessageInfo

type RpcObjectCreateRelationOptionRequest struct {
	Details *types.Struct `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateRelationOptionRequest proto.InternalMessageInfo

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

type RpcObjectCreateRelationOptionResponse struct {
	Error    *RpcObjectCreateRelationOptionResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                                      `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Details  *types.Struct                               `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateRelationOptionResponse proto.InternalMessageInfo

func (m *RpcObjectCreateRelationOptionResponse) GetError() *RpcObjectCreateRelationOptionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

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

var xxx_messageInfo_RpcObjectCreateRelationOptionResponseError proto.InternalMessageInfo

func (m *RpcObjectCreateRelationOptionResponseError) GetCode() RpcObjectCreateRelationOptionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCreateRelationOptionResponseError_NULL
}

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

type RpcObjectCreateSet struct {
}

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

var xxx_messageInfo_RpcObjectCreateSet proto.InternalMessageInfo

type RpcObjectCreateSetRequest 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"`
	InternalFlags []*model.InternalFlag `protobuf:"bytes,4,rep,name=internalFlags,proto3" json:"internalFlags,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateSetRequest proto.InternalMessageInfo

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

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

func (m *RpcObjectCreateSetRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

func (m *RpcObjectCreateSetRequest) GetInternalFlags() []*model.InternalFlag {
	if m != nil {
		return m.InternalFlags
	}
	return nil
}

type RpcObjectCreateSetResponse struct {
	Error    *RpcObjectCreateSetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                           `protobuf:"bytes,3,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Event    *ResponseEvent                   `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
	Details  *types.Struct                    `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateSetResponse proto.InternalMessageInfo

func (m *RpcObjectCreateSetResponse) GetError() *RpcObjectCreateSetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcObjectCreateSetResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcObjectCreateSetResponseError proto.InternalMessageInfo

func (m *RpcObjectCreateSetResponseError) GetCode() RpcObjectCreateSetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCreateSetResponseError_NULL
}

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

type RpcObjectCreateObjectType struct {
}

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

var xxx_messageInfo_RpcObjectCreateObjectType proto.InternalMessageInfo

type RpcObjectCreateObjectTypeRequest struct {
	Details       *types.Struct         `protobuf:"bytes,1,opt,name=details,proto3" json:"details,omitempty"`
	InternalFlags []*model.InternalFlag `protobuf:"bytes,2,rep,name=internalFlags,proto3" json:"internalFlags,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateObjectTypeRequest proto.InternalMessageInfo

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

func (m *RpcObjectCreateObjectTypeRequest) GetInternalFlags() []*model.InternalFlag {
	if m != nil {
		return m.InternalFlags
	}
	return nil
}

type RpcObjectCreateObjectTypeResponse struct {
	Error    *RpcObjectCreateObjectTypeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Details  *types.Struct                           `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	ObjectId string                                  `protobuf:"bytes,3,opt,name=objectId,proto3" json:"objectId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectCreateObjectTypeResponse proto.InternalMessageInfo

func (m *RpcObjectCreateObjectTypeResponse) GetError() *RpcObjectCreateObjectTypeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

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

var xxx_messageInfo_RpcObjectCreateObjectTypeResponseError proto.InternalMessageInfo

func (m *RpcObjectCreateObjectTypeResponseError) GetCode() RpcObjectCreateObjectTypeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectCreateObjectTypeResponseError_NULL
}

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

type RpcObjectBookmarkFetch struct {
}

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

var xxx_messageInfo_RpcObjectBookmarkFetch proto.InternalMessageInfo

type RpcObjectBookmarkFetchRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Url       string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
}

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

var xxx_messageInfo_RpcObjectBookmarkFetchRequest proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_RpcObjectBookmarkFetchResponse proto.InternalMessageInfo

func (m *RpcObjectBookmarkFetchResponse) GetError() *RpcObjectBookmarkFetchResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectBookmarkFetchResponseError proto.InternalMessageInfo

func (m *RpcObjectBookmarkFetchResponseError) GetCode() RpcObjectBookmarkFetchResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectBookmarkFetchResponseError_NULL
}

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

type RpcObjectToBookmark struct {
}

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

var xxx_messageInfo_RpcObjectToBookmark proto.InternalMessageInfo

type RpcObjectToBookmarkRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Url       string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
}

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

var xxx_messageInfo_RpcObjectToBookmarkRequest proto.InternalMessageInfo

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

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

type RpcObjectToBookmarkResponse struct {
	Error    *RpcObjectToBookmarkResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId string                            `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectToBookmarkResponse proto.InternalMessageInfo

func (m *RpcObjectToBookmarkResponse) GetError() *RpcObjectToBookmarkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcObjectToBookmarkResponseError proto.InternalMessageInfo

func (m *RpcObjectToBookmarkResponseError) GetCode() RpcObjectToBookmarkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectToBookmarkResponseError_NULL
}

func (m *RpcObjectToBookmarkResponseError) 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, 4, 11}
}
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 {
	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, 4, 11, 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, 4, 11, 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, 4, 11, 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 RpcObjectOpenBreadcrumbs struct {
}

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

var xxx_messageInfo_RpcObjectOpenBreadcrumbs proto.InternalMessageInfo

type RpcObjectOpenBreadcrumbsRequest 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 *RpcObjectOpenBreadcrumbsRequest) Reset()         { *m = RpcObjectOpenBreadcrumbsRequest{} }
func (m *RpcObjectOpenBreadcrumbsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectOpenBreadcrumbsRequest) ProtoMessage()    {}
func (*RpcObjectOpenBreadcrumbsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 12, 0}
}
func (m *RpcObjectOpenBreadcrumbsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectOpenBreadcrumbsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectOpenBreadcrumbsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectOpenBreadcrumbsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectOpenBreadcrumbsRequest.Merge(m, src)
}
func (m *RpcObjectOpenBreadcrumbsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectOpenBreadcrumbsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectOpenBreadcrumbsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectOpenBreadcrumbsRequest proto.InternalMessageInfo

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

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

type RpcObjectOpenBreadcrumbsResponse struct {
	Error      *RpcObjectOpenBreadcrumbsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectId   string                                 `protobuf:"bytes,2,opt,name=objectId,proto3" json:"objectId,omitempty"`
	Event      *ResponseEvent                         `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
	ObjectView *model.ObjectView                      `protobuf:"bytes,4,opt,name=objectView,proto3" json:"objectView,omitempty"`
}

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

var xxx_messageInfo_RpcObjectOpenBreadcrumbsResponse proto.InternalMessageInfo

func (m *RpcObjectOpenBreadcrumbsResponse) GetError() *RpcObjectOpenBreadcrumbsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcObjectOpenBreadcrumbsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcObjectOpenBreadcrumbsResponse) GetObjectView() *model.ObjectView {
	if m != nil {
		return m.ObjectView
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectOpenBreadcrumbsResponseError proto.InternalMessageInfo

func (m *RpcObjectOpenBreadcrumbsResponseError) GetCode() RpcObjectOpenBreadcrumbsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectOpenBreadcrumbsResponseError_NULL
}

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

type RpcObjectSetBreadcrumbs struct {
}

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

var xxx_messageInfo_RpcObjectSetBreadcrumbs proto.InternalMessageInfo

type RpcObjectSetBreadcrumbsRequest 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 *RpcObjectSetBreadcrumbsRequest) Reset()         { *m = RpcObjectSetBreadcrumbsRequest{} }
func (m *RpcObjectSetBreadcrumbsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetBreadcrumbsRequest) ProtoMessage()    {}
func (*RpcObjectSetBreadcrumbsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 13, 0}
}
func (m *RpcObjectSetBreadcrumbsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetBreadcrumbsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetBreadcrumbsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetBreadcrumbsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetBreadcrumbsRequest.Merge(m, src)
}
func (m *RpcObjectSetBreadcrumbsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetBreadcrumbsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetBreadcrumbsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetBreadcrumbsRequest proto.InternalMessageInfo

func (m *RpcObjectSetBreadcrumbsRequest) GetBreadcrumbsId() string {
	if m != nil {
		return m.BreadcrumbsId
	}
	return ""
}

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

type RpcObjectSetBreadcrumbsResponse struct {
	Error *RpcObjectSetBreadcrumbsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcObjectSetBreadcrumbsResponse proto.InternalMessageInfo

func (m *RpcObjectSetBreadcrumbsResponse) GetError() *RpcObjectSetBreadcrumbsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetBreadcrumbsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectSetBreadcrumbsResponseError proto.InternalMessageInfo

func (m *RpcObjectSetBreadcrumbsResponseError) GetCode() RpcObjectSetBreadcrumbsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetBreadcrumbsResponseError_NULL
}

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

type RpcObjectImportMarkdown struct {
}

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

var xxx_messageInfo_RpcObjectImportMarkdown proto.InternalMessageInfo

type RpcObjectImportMarkdownRequest 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 *RpcObjectImportMarkdownRequest) Reset()         { *m = RpcObjectImportMarkdownRequest{} }
func (m *RpcObjectImportMarkdownRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectImportMarkdownRequest) ProtoMessage()    {}
func (*RpcObjectImportMarkdownRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 14, 0}
}
func (m *RpcObjectImportMarkdownRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectImportMarkdownRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectImportMarkdownRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectImportMarkdownRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectImportMarkdownRequest.Merge(m, src)
}
func (m *RpcObjectImportMarkdownRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectImportMarkdownRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectImportMarkdownRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectImportMarkdownRequest proto.InternalMessageInfo

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

func (m *RpcObjectImportMarkdownRequest) GetImportPath() string {
	if m != nil {
		return m.ImportPath
	}
	return ""
}

type RpcObjectImportMarkdownResponse struct {
	Error       *RpcObjectImportMarkdownResponseError `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 *RpcObjectImportMarkdownResponse) Reset()         { *m = RpcObjectImportMarkdownResponse{} }
func (m *RpcObjectImportMarkdownResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectImportMarkdownResponse) ProtoMessage()    {}
func (*RpcObjectImportMarkdownResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 14, 1}
}
func (m *RpcObjectImportMarkdownResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectImportMarkdownResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectImportMarkdownResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectImportMarkdownResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectImportMarkdownResponse.Merge(m, src)
}
func (m *RpcObjectImportMarkdownResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectImportMarkdownResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectImportMarkdownResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectImportMarkdownResponse proto.InternalMessageInfo

func (m *RpcObjectImportMarkdownResponse) GetError() *RpcObjectImportMarkdownResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectImportMarkdownResponse) GetRootLinkIds() []string {
	if m != nil {
		return m.RootLinkIds
	}
	return nil
}

func (m *RpcObjectImportMarkdownResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectImportMarkdownResponseError proto.InternalMessageInfo

func (m *RpcObjectImportMarkdownResponseError) GetCode() RpcObjectImportMarkdownResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectImportMarkdownResponseError_NULL
}

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

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, 4, 15}
}
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, 4, 15, 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, 4, 15, 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, 4, 15, 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, 4, 16}
}
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, 4, 16, 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, 4, 16, 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, 4, 16, 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 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, 4, 17}
}
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, 4, 17, 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, 4, 17, 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, 4, 17, 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, 4, 18}
}
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"`
	Keys             []string `protobuf:"bytes,4,rep,name=keys,proto3" json:"keys,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, 4, 18, 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
}

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

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, 4, 18, 1}
}
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 []*types.Struct              `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, 4, 18, 2}
}
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() []*types.Struct {
	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, 4, 18, 2, 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, 4, 19}
}
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, 4, 19, 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, 4, 19, 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, 4, 19, 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 RpcObjectGroupsSubscribe struct {
}

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

var xxx_messageInfo_RpcObjectGroupsSubscribe proto.InternalMessageInfo

type RpcObjectGroupsSubscribeRequest struct {
	SubId       string                              `protobuf:"bytes,1,opt,name=subId,proto3" json:"subId,omitempty"`
	RelationKey string                              `protobuf:"bytes,2,opt,name=relationKey,proto3" json:"relationKey,omitempty"`
	Filters     []*model.BlockContentDataviewFilter `protobuf:"bytes,3,rep,name=filters,proto3" json:"filters,omitempty"`
	Source      []string                            `protobuf:"bytes,4,rep,name=source,proto3" json:"source,omitempty"`
}

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

var xxx_messageInfo_RpcObjectGroupsSubscribeRequest proto.InternalMessageInfo

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

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

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

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

type RpcObjectGroupsSubscribeResponse struct {
	Error  *RpcObjectGroupsSubscribeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Groups []*model.BlockContentDataviewGroup     `protobuf:"bytes,2,rep,name=groups,proto3" json:"groups,omitempty"`
	SubId  string                                 `protobuf:"bytes,3,opt,name=subId,proto3" json:"subId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectGroupsSubscribeResponse proto.InternalMessageInfo

func (m *RpcObjectGroupsSubscribeResponse) GetError() *RpcObjectGroupsSubscribeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectGroupsSubscribeResponse) GetGroups() []*model.BlockContentDataviewGroup {
	if m != nil {
		return m.Groups
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcObjectGroupsSubscribeResponseError proto.InternalMessageInfo

func (m *RpcObjectGroupsSubscribeResponseError) GetCode() RpcObjectGroupsSubscribeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectGroupsSubscribeResponseError_NULL
}

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

type RpcObjectSubscribeIds struct {
}

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

var xxx_messageInfo_RpcObjectSubscribeIds proto.InternalMessageInfo

type RpcObjectSubscribeIdsRequest 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 *RpcObjectSubscribeIdsRequest) Reset()         { *m = RpcObjectSubscribeIdsRequest{} }
func (m *RpcObjectSubscribeIdsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSubscribeIdsRequest) ProtoMessage()    {}
func (*RpcObjectSubscribeIdsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 21, 0}
}
func (m *RpcObjectSubscribeIdsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSubscribeIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSubscribeIdsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSubscribeIdsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSubscribeIdsRequest.Merge(m, src)
}
func (m *RpcObjectSubscribeIdsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSubscribeIdsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSubscribeIdsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSubscribeIdsRequest proto.InternalMessageInfo

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

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

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

func (m *RpcObjectSubscribeIdsRequest) GetIgnoreWorkspace() string {
	if m != nil {
		return m.IgnoreWorkspace
	}
	return ""
}

type RpcObjectSubscribeIdsResponse struct {
	Error        *RpcObjectSubscribeIdsResponseError `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 *RpcObjectSubscribeIdsResponse) Reset()         { *m = RpcObjectSubscribeIdsResponse{} }
func (m *RpcObjectSubscribeIdsResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSubscribeIdsResponse) ProtoMessage()    {}
func (*RpcObjectSubscribeIdsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 21, 1}
}
func (m *RpcObjectSubscribeIdsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSubscribeIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSubscribeIdsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSubscribeIdsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSubscribeIdsResponse.Merge(m, src)
}
func (m *RpcObjectSubscribeIdsResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSubscribeIdsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSubscribeIdsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSubscribeIdsResponse proto.InternalMessageInfo

func (m *RpcObjectSubscribeIdsResponse) GetError() *RpcObjectSubscribeIdsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

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

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

var xxx_messageInfo_RpcObjectSubscribeIdsResponseError proto.InternalMessageInfo

func (m *RpcObjectSubscribeIdsResponseError) GetCode() RpcObjectSubscribeIdsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSubscribeIdsResponseError_NULL
}

func (m *RpcObjectSubscribeIdsResponseError) 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, 4, 22}
}
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, 4, 22, 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, 4, 22, 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, 4, 22, 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, 4, 23}
}
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, 4, 23, 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, 4, 23, 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, 4, 23, 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, 4, 24}
}
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, 4, 24, 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, 4, 24, 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, 4, 24, 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, 4, 25}
}
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, 4, 25, 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, 4, 25, 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, 4, 25, 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 RpcObjectSetObjectType struct {
}

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

var xxx_messageInfo_RpcObjectSetObjectType proto.InternalMessageInfo

type RpcObjectSetObjectTypeRequest 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 *RpcObjectSetObjectTypeRequest) Reset()         { *m = RpcObjectSetObjectTypeRequest{} }
func (m *RpcObjectSetObjectTypeRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetObjectTypeRequest) ProtoMessage()    {}
func (*RpcObjectSetObjectTypeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 26, 0}
}
func (m *RpcObjectSetObjectTypeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetObjectTypeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetObjectTypeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetObjectTypeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetObjectTypeRequest.Merge(m, src)
}
func (m *RpcObjectSetObjectTypeRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetObjectTypeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetObjectTypeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetObjectTypeRequest proto.InternalMessageInfo

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

func (m *RpcObjectSetObjectTypeRequest) GetObjectTypeUrl() string {
	if m != nil {
		return m.ObjectTypeUrl
	}
	return ""
}

type RpcObjectSetObjectTypeResponse struct {
	Error *RpcObjectSetObjectTypeResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcObjectSetObjectTypeResponse proto.InternalMessageInfo

func (m *RpcObjectSetObjectTypeResponse) GetError() *RpcObjectSetObjectTypeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetObjectTypeResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectSetObjectTypeResponseError proto.InternalMessageInfo

func (m *RpcObjectSetObjectTypeResponseError) GetCode() RpcObjectSetObjectTypeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetObjectTypeResponseError_NULL
}

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

type RpcObjectSetInternalFlags struct {
}

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

var xxx_messageInfo_RpcObjectSetInternalFlags proto.InternalMessageInfo

type RpcObjectSetInternalFlagsRequest struct {
	ContextId     string                `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	InternalFlags []*model.InternalFlag `protobuf:"bytes,7,rep,name=internalFlags,proto3" json:"internalFlags,omitempty"`
}

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

var xxx_messageInfo_RpcObjectSetInternalFlagsRequest proto.InternalMessageInfo

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

func (m *RpcObjectSetInternalFlagsRequest) GetInternalFlags() []*model.InternalFlag {
	if m != nil {
		return m.InternalFlags
	}
	return nil
}

type RpcObjectSetInternalFlagsResponse struct {
	Error *RpcObjectSetInternalFlagsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcObjectSetInternalFlagsResponse proto.InternalMessageInfo

func (m *RpcObjectSetInternalFlagsResponse) GetError() *RpcObjectSetInternalFlagsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetInternalFlagsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectSetInternalFlagsResponseError proto.InternalMessageInfo

func (m *RpcObjectSetInternalFlagsResponseError) GetCode() RpcObjectSetInternalFlagsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetInternalFlagsResponseError_NULL
}

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

type RpcObjectSetDetails struct {
}

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

var xxx_messageInfo_RpcObjectSetDetails proto.InternalMessageInfo

type RpcObjectSetDetailsDetail 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 *RpcObjectSetDetailsDetail) Reset()         { *m = RpcObjectSetDetailsDetail{} }
func (m *RpcObjectSetDetailsDetail) String() string { return proto.CompactTextString(m) }
func (*RpcObjectSetDetailsDetail) ProtoMessage()    {}
func (*RpcObjectSetDetailsDetail) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 28, 0}
}
func (m *RpcObjectSetDetailsDetail) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectSetDetailsDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectSetDetailsDetail.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectSetDetailsDetail) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectSetDetailsDetail.Merge(m, src)
}
func (m *RpcObjectSetDetailsDetail) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectSetDetailsDetail) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectSetDetailsDetail.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectSetDetailsDetail proto.InternalMessageInfo

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

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

type RpcObjectSetDetailsRequest struct {
	ContextId string                       `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	Details   []*RpcObjectSetDetailsDetail `protobuf:"bytes,2,rep,name=details,proto3" json:"details,omitempty"`
}

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

var xxx_messageInfo_RpcObjectSetDetailsRequest proto.InternalMessageInfo

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

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

type RpcObjectSetDetailsResponse struct {
	Error *RpcObjectSetDetailsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcObjectSetDetailsResponse proto.InternalMessageInfo

func (m *RpcObjectSetDetailsResponse) GetError() *RpcObjectSetDetailsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectSetDetailsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectSetDetailsResponseError proto.InternalMessageInfo

func (m *RpcObjectSetDetailsResponseError) GetCode() RpcObjectSetDetailsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectSetDetailsResponseError_NULL
}

func (m *RpcObjectSetDetailsResponseError) 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, 4, 29}
}
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, 4, 29, 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, 4, 29, 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, 4, 29, 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 ""
}

// Available undo/redo operations
type RpcObjectUndoRedoCounter 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 *RpcObjectUndoRedoCounter) Reset()         { *m = RpcObjectUndoRedoCounter{} }
func (m *RpcObjectUndoRedoCounter) String() string { return proto.CompactTextString(m) }
func (*RpcObjectUndoRedoCounter) ProtoMessage()    {}
func (*RpcObjectUndoRedoCounter) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 30}
}
func (m *RpcObjectUndoRedoCounter) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectUndoRedoCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectUndoRedoCounter.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectUndoRedoCounter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectUndoRedoCounter.Merge(m, src)
}
func (m *RpcObjectUndoRedoCounter) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectUndoRedoCounter) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectUndoRedoCounter.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectUndoRedoCounter proto.InternalMessageInfo

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

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

type RpcObjectUndo struct {
}

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

var xxx_messageInfo_RpcObjectUndo proto.InternalMessageInfo

type RpcObjectUndoRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectUndoRequest proto.InternalMessageInfo

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

type RpcObjectUndoResponse struct {
	Error    *RpcObjectUndoResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event    *ResponseEvent              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	Counters *RpcObjectUndoRedoCounter   `protobuf:"bytes,3,opt,name=counters,proto3" json:"counters,omitempty"`
}

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

var xxx_messageInfo_RpcObjectUndoResponse proto.InternalMessageInfo

func (m *RpcObjectUndoResponse) GetError() *RpcObjectUndoResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectUndoResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcObjectUndoResponse) GetCounters() *RpcObjectUndoRedoCounter {
	if m != nil {
		return m.Counters
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectUndoResponseError proto.InternalMessageInfo

func (m *RpcObjectUndoResponseError) GetCode() RpcObjectUndoResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectUndoResponseError_NULL
}

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

type RpcObjectRedo struct {
}

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

var xxx_messageInfo_RpcObjectRedo proto.InternalMessageInfo

type RpcObjectRedoRequest struct {
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

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

var xxx_messageInfo_RpcObjectRedoRequest proto.InternalMessageInfo

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

type RpcObjectRedoResponse struct {
	Error    *RpcObjectRedoResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event    *ResponseEvent              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	Counters *RpcObjectUndoRedoCounter   `protobuf:"bytes,3,opt,name=counters,proto3" json:"counters,omitempty"`
}

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

var xxx_messageInfo_RpcObjectRedoResponse proto.InternalMessageInfo

func (m *RpcObjectRedoResponse) GetError() *RpcObjectRedoResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRedoResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *RpcObjectRedoResponse) GetCounters() *RpcObjectUndoRedoCounter {
	if m != nil {
		return m.Counters
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectRedoResponseError proto.InternalMessageInfo

func (m *RpcObjectRedoResponseError) GetCode() RpcObjectRedoResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRedoResponseError_NULL
}

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

type RpcObjectListDuplicate struct {
}

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

var xxx_messageInfo_RpcObjectListDuplicate proto.InternalMessageInfo

type RpcObjectListDuplicateRequest struct {
	ObjectIds []string `protobuf:"bytes,1,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
}

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

var xxx_messageInfo_RpcObjectListDuplicateRequest proto.InternalMessageInfo

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

type RpcObjectListDuplicateResponse struct {
	Error *RpcObjectListDuplicateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Ids   []string                             `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

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

var xxx_messageInfo_RpcObjectListDuplicateResponse proto.InternalMessageInfo

func (m *RpcObjectListDuplicateResponse) GetError() *RpcObjectListDuplicateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcObjectListDuplicateResponseError proto.InternalMessageInfo

func (m *RpcObjectListDuplicateResponseError) GetCode() RpcObjectListDuplicateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectListDuplicateResponseError_NULL
}

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

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, 4, 34}
}
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, 4, 34, 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, 4, 34, 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, 4, 34, 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 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, 4, 35}
}
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, 4, 35, 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, 4, 35, 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, 4, 35, 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, 4, 36}
}
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, 4, 36, 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, 4, 36, 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, 4, 36, 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 RpcObjectApplyTemplate struct {
}

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

var xxx_messageInfo_RpcObjectApplyTemplate proto.InternalMessageInfo

type RpcObjectApplyTemplateRequest 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 *RpcObjectApplyTemplateRequest) Reset()         { *m = RpcObjectApplyTemplateRequest{} }
func (m *RpcObjectApplyTemplateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectApplyTemplateRequest) ProtoMessage()    {}
func (*RpcObjectApplyTemplateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 37, 0}
}
func (m *RpcObjectApplyTemplateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectApplyTemplateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectApplyTemplateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectApplyTemplateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectApplyTemplateRequest.Merge(m, src)
}
func (m *RpcObjectApplyTemplateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectApplyTemplateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectApplyTemplateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectApplyTemplateRequest proto.InternalMessageInfo

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

func (m *RpcObjectApplyTemplateRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

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

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

var xxx_messageInfo_RpcObjectApplyTemplateResponse proto.InternalMessageInfo

func (m *RpcObjectApplyTemplateResponse) GetError() *RpcObjectApplyTemplateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectApplyTemplateResponseError proto.InternalMessageInfo

func (m *RpcObjectApplyTemplateResponseError) GetCode() RpcObjectApplyTemplateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectApplyTemplateResponseError_NULL
}

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

type RpcObjectListExport struct {
}

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

var xxx_messageInfo_RpcObjectListExport proto.InternalMessageInfo

type RpcObjectListExportRequest 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
	ObjectIds []string `protobuf:"bytes,2,rep,name=objectIds,proto3" json:"objectIds,omitempty"`
	// export format
	Format RpcObjectListExportFormat `protobuf:"varint,3,opt,name=format,proto3,enum=anytype.RpcObjectListExportFormat" 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 *RpcObjectListExportRequest) Reset()         { *m = RpcObjectListExportRequest{} }
func (m *RpcObjectListExportRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListExportRequest) ProtoMessage()    {}
func (*RpcObjectListExportRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 38, 0}
}
func (m *RpcObjectListExportRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListExportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListExportRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListExportRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListExportRequest.Merge(m, src)
}
func (m *RpcObjectListExportRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListExportRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListExportRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListExportRequest proto.InternalMessageInfo

func (m *RpcObjectListExportRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

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

func (m *RpcObjectListExportRequest) GetFormat() RpcObjectListExportFormat {
	if m != nil {
		return m.Format
	}
	return RpcObjectListExport_Markdown
}

func (m *RpcObjectListExportRequest) GetZip() bool {
	if m != nil {
		return m.Zip
	}
	return false
}

func (m *RpcObjectListExportRequest) GetIncludeNested() bool {
	if m != nil {
		return m.IncludeNested
	}
	return false
}

func (m *RpcObjectListExportRequest) GetIncludeFiles() bool {
	if m != nil {
		return m.IncludeFiles
	}
	return false
}

type RpcObjectListExportResponse struct {
	Error   *RpcObjectListExportResponseError `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 *RpcObjectListExportResponse) Reset()         { *m = RpcObjectListExportResponse{} }
func (m *RpcObjectListExportResponse) String() string { return proto.CompactTextString(m) }
func (*RpcObjectListExportResponse) ProtoMessage()    {}
func (*RpcObjectListExportResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 4, 38, 1}
}
func (m *RpcObjectListExportResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectListExportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectListExportResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectListExportResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectListExportResponse.Merge(m, src)
}
func (m *RpcObjectListExportResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectListExportResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectListExportResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectListExportResponse proto.InternalMessageInfo

func (m *RpcObjectListExportResponse) GetError() *RpcObjectListExportResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectListExportResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcObjectListExportResponse) GetSucceed() int32 {
	if m != nil {
		return m.Succeed
	}
	return 0
}

func (m *RpcObjectListExportResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectListExportResponseError proto.InternalMessageInfo

func (m *RpcObjectListExportResponseError) GetCode() RpcObjectListExportResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectListExportResponseError_NULL
}

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

type RpcObjectImport struct {
}

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

var xxx_messageInfo_RpcObjectImport proto.InternalMessageInfo

type RpcObjectImportRequest struct {
	// Types that are valid to be assigned to Params:
	//	*RpcObjectImportRequestParamsOfNotionParams
	//	*RpcObjectImportRequestParamsOfBookmarksParams
	//	*RpcObjectImportRequestParamsOfMarkdownParams
	Params                IsRpcObjectImportRequestParams    `protobuf_oneof:"params"`
	Snapshots             []*RpcObjectImportRequestSnapshot `protobuf:"bytes,4,rep,name=snapshots,proto3" json:"snapshots,omitempty"`
	UpdateExistingObjects bool                              `protobuf:"varint,5,opt,name=updateExistingObjects,proto3" json:"updateExistingObjects,omitempty"`
	Type                  RpcObjectImportRequestType        `protobuf:"varint,6,opt,name=type,proto3,enum=anytype.RpcObjectImportRequestType" json:"type,omitempty"`
	Mode                  RpcObjectImportRequestMode        `protobuf:"varint,7,opt,name=mode,proto3,enum=anytype.RpcObjectImportRequestMode" json:"mode,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportRequest proto.InternalMessageInfo

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

type RpcObjectImportRequestParamsOfNotionParams struct {
	NotionParams *RpcObjectImportRequestNotionParams `protobuf:"bytes,1,opt,name=notionParams,proto3,oneof" json:"notionParams,omitempty"`
}
type RpcObjectImportRequestParamsOfBookmarksParams struct {
	BookmarksParams *RpcObjectImportRequestBookmarksParams `protobuf:"bytes,2,opt,name=bookmarksParams,proto3,oneof" json:"bookmarksParams,omitempty"`
}
type RpcObjectImportRequestParamsOfMarkdownParams struct {
	MarkdownParams *RpcObjectImportRequestMarkdownParams `protobuf:"bytes,3,opt,name=markdownParams,proto3,oneof" json:"markdownParams,omitempty"`
}

func (*RpcObjectImportRequestParamsOfNotionParams) IsRpcObjectImportRequestParams()    {}
func (*RpcObjectImportRequestParamsOfBookmarksParams) IsRpcObjectImportRequestParams() {}
func (*RpcObjectImportRequestParamsOfMarkdownParams) IsRpcObjectImportRequestParams()  {}

func (m *RpcObjectImportRequest) GetParams() IsRpcObjectImportRequestParams {
	if m != nil {
		return m.Params
	}
	return nil
}

func (m *RpcObjectImportRequest) GetNotionParams() *RpcObjectImportRequestNotionParams {
	if x, ok := m.GetParams().(*RpcObjectImportRequestParamsOfNotionParams); ok {
		return x.NotionParams
	}
	return nil
}

func (m *RpcObjectImportRequest) GetBookmarksParams() *RpcObjectImportRequestBookmarksParams {
	if x, ok := m.GetParams().(*RpcObjectImportRequestParamsOfBookmarksParams); ok {
		return x.BookmarksParams
	}
	return nil
}

func (m *RpcObjectImportRequest) GetMarkdownParams() *RpcObjectImportRequestMarkdownParams {
	if x, ok := m.GetParams().(*RpcObjectImportRequestParamsOfMarkdownParams); ok {
		return x.MarkdownParams
	}
	return nil
}

func (m *RpcObjectImportRequest) GetSnapshots() []*RpcObjectImportRequestSnapshot {
	if m != nil {
		return m.Snapshots
	}
	return nil
}

func (m *RpcObjectImportRequest) GetUpdateExistingObjects() bool {
	if m != nil {
		return m.UpdateExistingObjects
	}
	return false
}

func (m *RpcObjectImportRequest) GetType() RpcObjectImportRequestType {
	if m != nil {
		return m.Type
	}
	return RpcObjectImportRequest_Notion
}

func (m *RpcObjectImportRequest) GetMode() RpcObjectImportRequestMode {
	if m != nil {
		return m.Mode
	}
	return RpcObjectImportRequest_ALL_OR_NOTHING
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RpcObjectImportRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RpcObjectImportRequestParamsOfNotionParams)(nil),
		(*RpcObjectImportRequestParamsOfBookmarksParams)(nil),
		(*RpcObjectImportRequestParamsOfMarkdownParams)(nil),
	}
}

type RpcObjectImportRequestNotionParams struct {
	ApiKey string `protobuf:"bytes,1,opt,name=apiKey,proto3" json:"apiKey,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportRequestNotionParams proto.InternalMessageInfo

func (m *RpcObjectImportRequestNotionParams) GetApiKey() string {
	if m != nil {
		return m.ApiKey
	}
	return ""
}

type RpcObjectImportRequestMarkdownParams struct {
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportRequestMarkdownParams proto.InternalMessageInfo

func (m *RpcObjectImportRequestMarkdownParams) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type RpcObjectImportRequestBookmarksParams struct {
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportRequestBookmarksParams proto.InternalMessageInfo

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

type RpcObjectImportRequestSnapshot struct {
	Id       string                        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Snapshot *model.SmartBlockSnapshotBase `protobuf:"bytes,2,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportRequestSnapshot proto.InternalMessageInfo

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

func (m *RpcObjectImportRequestSnapshot) GetSnapshot() *model.SmartBlockSnapshotBase {
	if m != nil {
		return m.Snapshot
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectImportResponse proto.InternalMessageInfo

func (m *RpcObjectImportResponse) GetError() *RpcObjectImportResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectImportResponseError proto.InternalMessageInfo

func (m *RpcObjectImportResponseError) GetCode() RpcObjectImportResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectImportResponseError_NULL
}

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

type RpcObjectImportNotion struct {
}

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

var xxx_messageInfo_RpcObjectImportNotion proto.InternalMessageInfo

type RpcObjectImportNotionTokenValidate struct {
}

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

var xxx_messageInfo_RpcObjectImportNotionTokenValidate proto.InternalMessageInfo

type RpcObjectImportNotionTokenValidateRequest struct {
	ApiKey string `protobuf:"bytes,1,opt,name=apiKey,proto3" json:"apiKey,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportNotionTokenValidateRequest proto.InternalMessageInfo

func (m *RpcObjectImportNotionTokenValidateRequest) GetApiKey() string {
	if m != nil {
		return m.ApiKey
	}
	return ""
}

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

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

var xxx_messageInfo_RpcObjectImportNotionTokenValidateResponse proto.InternalMessageInfo

func (m *RpcObjectImportNotionTokenValidateResponse) GetError() *RpcObjectImportNotionTokenValidateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectImportNotionTokenValidateResponseError proto.InternalMessageInfo

func (m *RpcObjectImportNotionTokenValidateResponseError) GetCode() RpcObjectImportNotionTokenValidateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectImportNotionTokenValidateResponseError_NULL
}

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

type RpcObjectImportList struct {
}

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

var xxx_messageInfo_RpcObjectImportList proto.InternalMessageInfo

type RpcObjectImportListRequest struct {
}

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

var xxx_messageInfo_RpcObjectImportListRequest proto.InternalMessageInfo

type RpcObjectImportListResponse struct {
	Error    *RpcObjectImportListResponseError    `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Response []*RpcObjectImportListImportResponse `protobuf:"bytes,2,rep,name=response,proto3" json:"response,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportListResponse proto.InternalMessageInfo

func (m *RpcObjectImportListResponse) GetError() *RpcObjectImportListResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectImportListResponse) GetResponse() []*RpcObjectImportListImportResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectImportListResponseError proto.InternalMessageInfo

func (m *RpcObjectImportListResponseError) GetCode() RpcObjectImportListResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectImportListResponseError_NULL
}

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

type RpcObjectImportListImportResponse struct {
	Type RpcObjectImportListImportResponseType `protobuf:"varint,1,opt,name=type,proto3,enum=anytype.RpcObjectImportListImportResponseType" json:"type,omitempty"`
}

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

var xxx_messageInfo_RpcObjectImportListImportResponse proto.InternalMessageInfo

func (m *RpcObjectImportListImportResponse) GetType() RpcObjectImportListImportResponseType {
	if m != nil {
		return m.Type
	}
	return RpcObjectImportListImportResponse_Notion
}

type RpcObjectRelation struct {
}

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

var xxx_messageInfo_RpcObjectRelation proto.InternalMessageInfo

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, 5, 0}
}
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"`
	RelationKeys []string `protobuf:"bytes,2,rep,name=relationKeys,proto3" json:"relationKeys,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, 5, 0, 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) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	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"`
}

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, 5, 0, 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
}

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, 5, 0, 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 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, 5, 1}
}
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"`
	RelationKeys []string `protobuf:"bytes,2,rep,name=relationKeys,proto3" json:"relationKeys,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, 5, 1, 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) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	return nil
}

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, 5, 1, 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, 5, 1, 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 ""
}

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, 5, 2}
}
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, 5, 2, 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, 5, 2, 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, 5, 2, 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 RpcObjectRelationAddFeatured struct {
}

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

var xxx_messageInfo_RpcObjectRelationAddFeatured proto.InternalMessageInfo

type RpcObjectRelationAddFeaturedRequest 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 *RpcObjectRelationAddFeaturedRequest) Reset()         { *m = RpcObjectRelationAddFeaturedRequest{} }
func (m *RpcObjectRelationAddFeaturedRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationAddFeaturedRequest) ProtoMessage()    {}
func (*RpcObjectRelationAddFeaturedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 3, 0}
}
func (m *RpcObjectRelationAddFeaturedRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationAddFeaturedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationAddFeaturedRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationAddFeaturedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationAddFeaturedRequest.Merge(m, src)
}
func (m *RpcObjectRelationAddFeaturedRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationAddFeaturedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationAddFeaturedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationAddFeaturedRequest proto.InternalMessageInfo

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

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

type RpcObjectRelationAddFeaturedResponse struct {
	Error *RpcObjectRelationAddFeaturedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcObjectRelationAddFeaturedResponse proto.InternalMessageInfo

func (m *RpcObjectRelationAddFeaturedResponse) GetError() *RpcObjectRelationAddFeaturedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationAddFeaturedResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectRelationAddFeaturedResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationAddFeaturedResponseError) GetCode() RpcObjectRelationAddFeaturedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationAddFeaturedResponseError_NULL
}

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

type RpcObjectRelationRemoveFeatured struct {
}

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

var xxx_messageInfo_RpcObjectRelationRemoveFeatured proto.InternalMessageInfo

type RpcObjectRelationRemoveFeaturedRequest 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 *RpcObjectRelationRemoveFeaturedRequest) Reset() {
	*m = RpcObjectRelationRemoveFeaturedRequest{}
}
func (m *RpcObjectRelationRemoveFeaturedRequest) String() string { return proto.CompactTextString(m) }
func (*RpcObjectRelationRemoveFeaturedRequest) ProtoMessage()    {}
func (*RpcObjectRelationRemoveFeaturedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 5, 4, 0}
}
func (m *RpcObjectRelationRemoveFeaturedRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcObjectRelationRemoveFeaturedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcObjectRelationRemoveFeaturedRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcObjectRelationRemoveFeaturedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcObjectRelationRemoveFeaturedRequest.Merge(m, src)
}
func (m *RpcObjectRelationRemoveFeaturedRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcObjectRelationRemoveFeaturedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcObjectRelationRemoveFeaturedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcObjectRelationRemoveFeaturedRequest proto.InternalMessageInfo

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

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

type RpcObjectRelationRemoveFeaturedResponse struct {
	Error *RpcObjectRelationRemoveFeaturedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcObjectRelationRemoveFeaturedResponse proto.InternalMessageInfo

func (m *RpcObjectRelationRemoveFeaturedResponse) GetError() *RpcObjectRelationRemoveFeaturedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcObjectRelationRemoveFeaturedResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcObjectRelationRemoveFeaturedResponseError proto.InternalMessageInfo

func (m *RpcObjectRelationRemoveFeaturedResponseError) GetCode() RpcObjectRelationRemoveFeaturedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcObjectRelationRemoveFeaturedResponseError_NULL
}

func (m *RpcObjectRelationRemoveFeaturedResponseError) 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, 6}
}
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 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, 6, 0}
}
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, 6, 0, 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"`
	RelationKeys  []string `protobuf:"bytes,2,rep,name=relationKeys,proto3" json:"relationKeys,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, 6, 0, 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) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	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, 6, 0, 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, 6, 0, 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, 6, 0, 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"`
	RelationKeys  []string `protobuf:"bytes,2,rep,name=relationKeys,proto3" json:"relationKeys,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, 6, 0, 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) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	return nil
}

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, 6, 0, 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, 6, 0, 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 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, 6, 0, 2}
}
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, 6, 0, 2, 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.RelationLink                   `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, 6, 0, 2, 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.RelationLink {
	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, 6, 0, 2, 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 RpcRelation struct {
}

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

var xxx_messageInfo_RpcRelation proto.InternalMessageInfo

type RpcRelationListRemoveOption struct {
}

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

var xxx_messageInfo_RpcRelationListRemoveOption proto.InternalMessageInfo

type RpcRelationListRemoveOptionRequest struct {
	OptionIds      []string `protobuf:"bytes,1,rep,name=optionIds,proto3" json:"optionIds,omitempty"`
	CheckInObjects bool     `protobuf:"varint,2,opt,name=checkInObjects,proto3" json:"checkInObjects,omitempty"`
}

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

var xxx_messageInfo_RpcRelationListRemoveOptionRequest proto.InternalMessageInfo

func (m *RpcRelationListRemoveOptionRequest) GetOptionIds() []string {
	if m != nil {
		return m.OptionIds
	}
	return nil
}

func (m *RpcRelationListRemoveOptionRequest) GetCheckInObjects() bool {
	if m != nil {
		return m.CheckInObjects
	}
	return false
}

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

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

var xxx_messageInfo_RpcRelationListRemoveOptionResponse proto.InternalMessageInfo

func (m *RpcRelationListRemoveOptionResponse) GetError() *RpcRelationListRemoveOptionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcRelationListRemoveOptionResponseError proto.InternalMessageInfo

func (m *RpcRelationListRemoveOptionResponseError) GetCode() RpcRelationListRemoveOptionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcRelationListRemoveOptionResponseError_NULL
}

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

type RpcRelationOptions struct {
}

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

var xxx_messageInfo_RpcRelationOptions proto.InternalMessageInfo

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

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

var xxx_messageInfo_RpcRelationOptionsRequest proto.InternalMessageInfo

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

type RpcRelationOptionsResponse struct {
	Error   *RpcRelationOptionsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Options *model.RelationOptions           `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
}

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

var xxx_messageInfo_RpcRelationOptionsResponse proto.InternalMessageInfo

func (m *RpcRelationOptionsResponse) GetError() *RpcRelationOptionsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcRelationOptionsResponse) GetOptions() *model.RelationOptions {
	if m != nil {
		return m.Options
	}
	return nil
}

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

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

var xxx_messageInfo_RpcRelationOptionsResponseError proto.InternalMessageInfo

func (m *RpcRelationOptionsResponseError) GetCode() RpcRelationOptionsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcRelationOptionsResponseError_NULL
}

func (m *RpcRelationOptionsResponseError) 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, 8}
}
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

type RpcHistoryVersion 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 *RpcHistoryVersion) Reset()         { *m = RpcHistoryVersion{} }
func (m *RpcHistoryVersion) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryVersion) ProtoMessage()    {}
func (*RpcHistoryVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 0}
}
func (m *RpcHistoryVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryVersion.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryVersion.Merge(m, src)
}
func (m *RpcHistoryVersion) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryVersion.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryVersion proto.InternalMessageInfo

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

func (m *RpcHistoryVersion) GetPreviousIds() []string {
	if m != nil {
		return m.PreviousIds
	}
	return nil
}

func (m *RpcHistoryVersion) GetAuthorId() string {
	if m != nil {
		return m.AuthorId
	}
	return ""
}

func (m *RpcHistoryVersion) GetAuthorName() string {
	if m != nil {
		return m.AuthorName
	}
	return ""
}

func (m *RpcHistoryVersion) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *RpcHistoryVersion) GetGroupId() int64 {
	if m != nil {
		return m.GroupId
	}
	return 0
}

// returns list of versions (changes)
type RpcHistoryGetVersions struct {
}

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

var xxx_messageInfo_RpcHistoryGetVersions proto.InternalMessageInfo

type RpcHistoryGetVersionsRequest struct {
	ObjectId string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,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 *RpcHistoryGetVersionsRequest) Reset()         { *m = RpcHistoryGetVersionsRequest{} }
func (m *RpcHistoryGetVersionsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryGetVersionsRequest) ProtoMessage()    {}
func (*RpcHistoryGetVersionsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 1, 0}
}
func (m *RpcHistoryGetVersionsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryGetVersionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryGetVersionsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryGetVersionsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryGetVersionsRequest.Merge(m, src)
}
func (m *RpcHistoryGetVersionsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryGetVersionsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryGetVersionsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryGetVersionsRequest proto.InternalMessageInfo

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

func (m *RpcHistoryGetVersionsRequest) GetLastVersionId() string {
	if m != nil {
		return m.LastVersionId
	}
	return ""
}

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

type RpcHistoryGetVersionsResponse struct {
	Error    *RpcHistoryGetVersionsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Versions []*RpcHistoryVersion                `protobuf:"bytes,2,rep,name=versions,proto3" json:"versions,omitempty"`
}

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

var xxx_messageInfo_RpcHistoryGetVersionsResponse proto.InternalMessageInfo

func (m *RpcHistoryGetVersionsResponse) GetError() *RpcHistoryGetVersionsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcHistoryGetVersionsResponse) GetVersions() []*RpcHistoryVersion {
	if m != nil {
		return m.Versions
	}
	return nil
}

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

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

var xxx_messageInfo_RpcHistoryGetVersionsResponseError proto.InternalMessageInfo

func (m *RpcHistoryGetVersionsResponseError) GetCode() RpcHistoryGetVersionsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcHistoryGetVersionsResponseError_NULL
}

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

// returns blockShow event for given version
type RpcHistoryShowVersion struct {
}

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

var xxx_messageInfo_RpcHistoryShowVersion proto.InternalMessageInfo

type RpcHistoryShowVersionRequest struct {
	ObjectId  string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,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 *RpcHistoryShowVersionRequest) Reset()         { *m = RpcHistoryShowVersionRequest{} }
func (m *RpcHistoryShowVersionRequest) String() string { return proto.CompactTextString(m) }
func (*RpcHistoryShowVersionRequest) ProtoMessage()    {}
func (*RpcHistoryShowVersionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 8, 2, 0}
}
func (m *RpcHistoryShowVersionRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcHistoryShowVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcHistoryShowVersionRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcHistoryShowVersionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcHistoryShowVersionRequest.Merge(m, src)
}
func (m *RpcHistoryShowVersionRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcHistoryShowVersionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcHistoryShowVersionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcHistoryShowVersionRequest proto.InternalMessageInfo

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

func (m *RpcHistoryShowVersionRequest) GetVersionId() string {
	if m != nil {
		return m.VersionId
	}
	return ""
}

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

type RpcHistoryShowVersionResponse struct {
	Error      *RpcHistoryShowVersionResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	ObjectView *model.ObjectView                   `protobuf:"bytes,2,opt,name=objectView,proto3" json:"objectView,omitempty"`
	Version    *RpcHistoryVersion                  `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	TraceId    string                              `protobuf:"bytes,4,opt,name=traceId,proto3" json:"traceId,omitempty"`
}

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

var xxx_messageInfo_RpcHistoryShowVersionResponse proto.InternalMessageInfo

func (m *RpcHistoryShowVersionResponse) GetError() *RpcHistoryShowVersionResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcHistoryShowVersionResponse) GetObjectView() *model.ObjectView {
	if m != nil {
		return m.ObjectView
	}
	return nil
}

func (m *RpcHistoryShowVersionResponse) GetVersion() *RpcHistoryVersion {
	if m != nil {
		return m.Version
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcHistoryShowVersionResponseError proto.InternalMessageInfo

func (m *RpcHistoryShowVersionResponseError) GetCode() RpcHistoryShowVersionResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcHistoryShowVersionResponseError_NULL
}

func (m *RpcHistoryShowVersionResponseError) 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, 8, 3}
}
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 {
	ObjectId  string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,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, 8, 3, 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) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	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, 8, 3, 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, 8, 3, 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 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 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, 9, 1}
}
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, 9, 1, 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, 9, 1, 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, 9, 1, 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 RpcFileUpload struct {
}

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

var xxx_messageInfo_RpcFileUpload proto.InternalMessageInfo

type RpcFileUploadRequest 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 *RpcFileUploadRequest) Reset()         { *m = RpcFileUploadRequest{} }
func (m *RpcFileUploadRequest) String() string { return proto.CompactTextString(m) }
func (*RpcFileUploadRequest) ProtoMessage()    {}
func (*RpcFileUploadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 2, 0}
}
func (m *RpcFileUploadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileUploadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileUploadRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileUploadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileUploadRequest.Merge(m, src)
}
func (m *RpcFileUploadRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileUploadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileUploadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileUploadRequest proto.InternalMessageInfo

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

func (m *RpcFileUploadRequest) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

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

func (m *RpcFileUploadRequest) GetDisableEncryption() bool {
	if m != nil {
		return m.DisableEncryption
	}
	return false
}

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

type RpcFileUploadResponse struct {
	Error *RpcFileUploadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Hash  string                      `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}

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

var xxx_messageInfo_RpcFileUploadResponse proto.InternalMessageInfo

func (m *RpcFileUploadResponse) GetError() *RpcFileUploadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcFileUploadResponseError proto.InternalMessageInfo

func (m *RpcFileUploadResponseError) GetCode() RpcFileUploadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcFileUploadResponseError_NULL
}

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

type RpcFileDownload struct {
}

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

var xxx_messageInfo_RpcFileDownload proto.InternalMessageInfo

type RpcFileDownloadRequest 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 *RpcFileDownloadRequest) Reset()         { *m = RpcFileDownloadRequest{} }
func (m *RpcFileDownloadRequest) String() string { return proto.CompactTextString(m) }
func (*RpcFileDownloadRequest) ProtoMessage()    {}
func (*RpcFileDownloadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 3, 0}
}
func (m *RpcFileDownloadRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileDownloadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileDownloadRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileDownloadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileDownloadRequest.Merge(m, src)
}
func (m *RpcFileDownloadRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileDownloadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileDownloadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileDownloadRequest proto.InternalMessageInfo

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

func (m *RpcFileDownloadRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type RpcFileDownloadResponse struct {
	Error     *RpcFileDownloadResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LocalPath string                        `protobuf:"bytes,2,opt,name=localPath,proto3" json:"localPath,omitempty"`
}

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

var xxx_messageInfo_RpcFileDownloadResponse proto.InternalMessageInfo

func (m *RpcFileDownloadResponse) GetError() *RpcFileDownloadResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcFileDownloadResponse) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

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

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

var xxx_messageInfo_RpcFileDownloadResponseError proto.InternalMessageInfo

func (m *RpcFileDownloadResponseError) GetCode() RpcFileDownloadResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcFileDownloadResponseError_NULL
}

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

type RpcFileDrop struct {
}

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

var xxx_messageInfo_RpcFileDrop proto.InternalMessageInfo

type RpcFileDropRequest 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 *RpcFileDropRequest) Reset()         { *m = RpcFileDropRequest{} }
func (m *RpcFileDropRequest) String() string { return proto.CompactTextString(m) }
func (*RpcFileDropRequest) ProtoMessage()    {}
func (*RpcFileDropRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 9, 4, 0}
}
func (m *RpcFileDropRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcFileDropRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcFileDropRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcFileDropRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcFileDropRequest.Merge(m, src)
}
func (m *RpcFileDropRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcFileDropRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcFileDropRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcFileDropRequest proto.InternalMessageInfo

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

func (m *RpcFileDropRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcFileDropRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *RpcFileDropRequest) GetLocalFilePaths() []string {
	if m != nil {
		return m.LocalFilePaths
	}
	return nil
}

type RpcFileDropResponse struct {
	Error *RpcFileDropResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent            `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcFileDropResponse proto.InternalMessageInfo

func (m *RpcFileDropResponse) GetError() *RpcFileDropResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcFileDropResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcFileDropResponseError proto.InternalMessageInfo

func (m *RpcFileDropResponseError) GetCode() RpcFileDropResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcFileDropResponseError_NULL
}

func (m *RpcFileDropResponseError) 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, 10}
}
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, 10, 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, 10, 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, 10, 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, 10, 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, 10, 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, 10, 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, 10, 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, 10, 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 RpcTemplate struct {
}

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

var xxx_messageInfo_RpcTemplate proto.InternalMessageInfo

type RpcTemplateCreateFromObject struct {
}

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

var xxx_messageInfo_RpcTemplateCreateFromObject proto.InternalMessageInfo

type RpcTemplateCreateFromObjectRequest struct {
	// id of block for making them template
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

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

var xxx_messageInfo_RpcTemplateCreateFromObjectRequest proto.InternalMessageInfo

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

type RpcTemplateCreateFromObjectResponse struct {
	Error *RpcTemplateCreateFromObjectResponseError `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 *RpcTemplateCreateFromObjectResponse) Reset()         { *m = RpcTemplateCreateFromObjectResponse{} }
func (m *RpcTemplateCreateFromObjectResponse) String() string { return proto.CompactTextString(m) }
func (*RpcTemplateCreateFromObjectResponse) ProtoMessage()    {}
func (*RpcTemplateCreateFromObjectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 0, 1}
}
func (m *RpcTemplateCreateFromObjectResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcTemplateCreateFromObjectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcTemplateCreateFromObjectResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcTemplateCreateFromObjectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcTemplateCreateFromObjectResponse.Merge(m, src)
}
func (m *RpcTemplateCreateFromObjectResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcTemplateCreateFromObjectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcTemplateCreateFromObjectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcTemplateCreateFromObjectResponse proto.InternalMessageInfo

func (m *RpcTemplateCreateFromObjectResponse) GetError() *RpcTemplateCreateFromObjectResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcTemplateCreateFromObjectResponseError proto.InternalMessageInfo

func (m *RpcTemplateCreateFromObjectResponseError) GetCode() RpcTemplateCreateFromObjectResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcTemplateCreateFromObjectResponseError_NULL
}

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

type RpcTemplateCreateFromObjectType struct {
}

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

var xxx_messageInfo_RpcTemplateCreateFromObjectType proto.InternalMessageInfo

type RpcTemplateCreateFromObjectTypeRequest struct {
	// id of desired object type
	ObjectType string `protobuf:"bytes,1,opt,name=objectType,proto3" json:"objectType,omitempty"`
}

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

var xxx_messageInfo_RpcTemplateCreateFromObjectTypeRequest proto.InternalMessageInfo

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

type RpcTemplateCreateFromObjectTypeResponse struct {
	Error *RpcTemplateCreateFromObjectTypeResponseError `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 *RpcTemplateCreateFromObjectTypeResponse) Reset() {
	*m = RpcTemplateCreateFromObjectTypeResponse{}
}
func (m *RpcTemplateCreateFromObjectTypeResponse) String() string { return proto.CompactTextString(m) }
func (*RpcTemplateCreateFromObjectTypeResponse) ProtoMessage()    {}
func (*RpcTemplateCreateFromObjectTypeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 1, 1}
}
func (m *RpcTemplateCreateFromObjectTypeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcTemplateCreateFromObjectTypeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcTemplateCreateFromObjectTypeResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcTemplateCreateFromObjectTypeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcTemplateCreateFromObjectTypeResponse.Merge(m, src)
}
func (m *RpcTemplateCreateFromObjectTypeResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcTemplateCreateFromObjectTypeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcTemplateCreateFromObjectTypeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcTemplateCreateFromObjectTypeResponse proto.InternalMessageInfo

func (m *RpcTemplateCreateFromObjectTypeResponse) GetError() *RpcTemplateCreateFromObjectTypeResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcTemplateCreateFromObjectTypeResponseError proto.InternalMessageInfo

func (m *RpcTemplateCreateFromObjectTypeResponseError) GetCode() RpcTemplateCreateFromObjectTypeResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcTemplateCreateFromObjectTypeResponseError_NULL
}

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

type RpcTemplateClone struct {
}

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

var xxx_messageInfo_RpcTemplateClone proto.InternalMessageInfo

type RpcTemplateCloneRequest struct {
	// id of template block for cloning
	ContextId string `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
}

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

var xxx_messageInfo_RpcTemplateCloneRequest proto.InternalMessageInfo

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

type RpcTemplateCloneResponse struct {
	Error *RpcTemplateCloneResponseError `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 *RpcTemplateCloneResponse) Reset()         { *m = RpcTemplateCloneResponse{} }
func (m *RpcTemplateCloneResponse) String() string { return proto.CompactTextString(m) }
func (*RpcTemplateCloneResponse) ProtoMessage()    {}
func (*RpcTemplateCloneResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 2, 1}
}
func (m *RpcTemplateCloneResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcTemplateCloneResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcTemplateCloneResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcTemplateCloneResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcTemplateCloneResponse.Merge(m, src)
}
func (m *RpcTemplateCloneResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcTemplateCloneResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcTemplateCloneResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcTemplateCloneResponse proto.InternalMessageInfo

func (m *RpcTemplateCloneResponse) GetError() *RpcTemplateCloneResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcTemplateCloneResponseError proto.InternalMessageInfo

func (m *RpcTemplateCloneResponseError) GetCode() RpcTemplateCloneResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcTemplateCloneResponseError_NULL
}

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

type RpcTemplateExportAll struct {
}

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

var xxx_messageInfo_RpcTemplateExportAll proto.InternalMessageInfo

type RpcTemplateExportAllRequest struct {
	// the path where export files will place
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
}

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

var xxx_messageInfo_RpcTemplateExportAllRequest proto.InternalMessageInfo

func (m *RpcTemplateExportAllRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type RpcTemplateExportAllResponse struct {
	Error *RpcTemplateExportAllResponseError `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 *RpcTemplateExportAllResponse) Reset()         { *m = RpcTemplateExportAllResponse{} }
func (m *RpcTemplateExportAllResponse) String() string { return proto.CompactTextString(m) }
func (*RpcTemplateExportAllResponse) ProtoMessage()    {}
func (*RpcTemplateExportAllResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 11, 3, 1}
}
func (m *RpcTemplateExportAllResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcTemplateExportAllResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcTemplateExportAllResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcTemplateExportAllResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcTemplateExportAllResponse.Merge(m, src)
}
func (m *RpcTemplateExportAllResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcTemplateExportAllResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcTemplateExportAllResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcTemplateExportAllResponse proto.InternalMessageInfo

func (m *RpcTemplateExportAllResponse) GetError() *RpcTemplateExportAllResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcTemplateExportAllResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcTemplateExportAllResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcTemplateExportAllResponseError proto.InternalMessageInfo

func (m *RpcTemplateExportAllResponseError) GetCode() RpcTemplateExportAllResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcTemplateExportAllResponseError_NULL
}

func (m *RpcTemplateExportAllResponseError) 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, 12}
}
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, 12, 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, 12, 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, 12, 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 RpcUnsplash struct {
}

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

var xxx_messageInfo_RpcUnsplash proto.InternalMessageInfo

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, 13, 0}
}
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, 13, 0, 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, 13, 0, 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, 13, 0, 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, 13, 0, 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, 13, 1}
}
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, 13, 1, 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, 13, 1, 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, 13, 1, 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 ""
}

// Block commands
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, 14}
}
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, 14, 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, 14, 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, 14, 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, 14, 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 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, 14, 1}
}
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, 14, 1, 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, 14, 1, 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, 14, 1, 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, 14, 2}
}
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, 14, 2, 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, 14, 2, 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, 14, 2, 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, 14, 3}
}
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, 14, 3, 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, 14, 3, 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, 14, 3, 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, 14, 4}
}
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, 14, 4, 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, 14, 4, 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, 14, 4, 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, 14, 4, 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, 14, 5}
}
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, 14, 5, 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, 14, 5, 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, 14, 5, 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 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, 14, 6}
}
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, 14, 6, 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, 14, 6, 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, 14, 6, 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, 14, 7}
}
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, 14, 7, 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, 14, 7, 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, 14, 7, 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 ""
}

// 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, 14, 8}
}
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, 14, 8, 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, 14, 8, 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, 14, 8, 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 RpcBlockCreateWidget struct {
}

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

var xxx_messageInfo_RpcBlockCreateWidget proto.InternalMessageInfo

type RpcBlockCreateWidgetRequest 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"`
	WidgetLayout model.BlockContentWidgetLayout `protobuf:"varint,5,opt,name=widgetLayout,proto3,enum=anytype.model.BlockContentWidgetLayout" json:"widgetLayout,omitempty"`
}

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

var xxx_messageInfo_RpcBlockCreateWidgetRequest proto.InternalMessageInfo

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

func (m *RpcBlockCreateWidgetRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreateWidgetRequest) GetBlock() *model.Block {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *RpcBlockCreateWidgetRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *RpcBlockCreateWidgetRequest) GetWidgetLayout() model.BlockContentWidgetLayout {
	if m != nil {
		return m.WidgetLayout
	}
	return model.BlockContentWidget_Link
}

type RpcBlockCreateWidgetResponse struct {
	Error   *RpcBlockCreateWidgetResponseError `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 *RpcBlockCreateWidgetResponse) Reset()         { *m = RpcBlockCreateWidgetResponse{} }
func (m *RpcBlockCreateWidgetResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockCreateWidgetResponse) ProtoMessage()    {}
func (*RpcBlockCreateWidgetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 9, 1}
}
func (m *RpcBlockCreateWidgetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockCreateWidgetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockCreateWidgetResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockCreateWidgetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockCreateWidgetResponse.Merge(m, src)
}
func (m *RpcBlockCreateWidgetResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockCreateWidgetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockCreateWidgetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockCreateWidgetResponse proto.InternalMessageInfo

func (m *RpcBlockCreateWidgetResponse) GetError() *RpcBlockCreateWidgetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcBlockCreateWidgetResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockCreateWidgetResponseError proto.InternalMessageInfo

func (m *RpcBlockCreateWidgetResponseError) GetCode() RpcBlockCreateWidgetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCreateWidgetResponseError_NULL
}

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

// Remove blocks from the childrenIds of its parents
type RpcBlockListDelete struct {
}

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

var xxx_messageInfo_RpcBlockListDelete proto.InternalMessageInfo

type RpcBlockListDeleteRequest 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 *RpcBlockListDeleteRequest) Reset()         { *m = RpcBlockListDeleteRequest{} }
func (m *RpcBlockListDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockListDeleteRequest) ProtoMessage()    {}
func (*RpcBlockListDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 10, 0}
}
func (m *RpcBlockListDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockListDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockListDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockListDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockListDeleteRequest.Merge(m, src)
}
func (m *RpcBlockListDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockListDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockListDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockListDeleteRequest proto.InternalMessageInfo

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

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

type RpcBlockListDeleteResponse struct {
	Error *RpcBlockListDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                   `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockListDeleteResponse) GetError() *RpcBlockListDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockListDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockListDeleteResponseError) GetCode() RpcBlockListDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListDeleteResponseError_NULL
}

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

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, 14, 11}
}
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, 14, 11, 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, 14, 11, 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, 14, 11, 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 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, 14, 12}
}
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, 14, 12, 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, 14, 12, 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, 14, 12, 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 RpcBlockListSetVerticalAlign struct {
}

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

var xxx_messageInfo_RpcBlockListSetVerticalAlign proto.InternalMessageInfo

type RpcBlockListSetVerticalAlignRequest 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"`
	VerticalAlign model.BlockVerticalAlign `protobuf:"varint,3,opt,name=verticalAlign,proto3,enum=anytype.model.BlockVerticalAlign" json:"verticalAlign,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetVerticalAlignRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListSetVerticalAlignResponse struct {
	Error *RpcBlockListSetVerticalAlignResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListSetVerticalAlignResponse proto.InternalMessageInfo

func (m *RpcBlockListSetVerticalAlignResponse) GetError() *RpcBlockListSetVerticalAlignResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListSetVerticalAlignResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockListSetVerticalAlignResponseError proto.InternalMessageInfo

func (m *RpcBlockListSetVerticalAlignResponseError) GetCode() RpcBlockListSetVerticalAlignResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListSetVerticalAlignResponseError_NULL
}

func (m *RpcBlockListSetVerticalAlignResponseError) 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, 14, 14}
}
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, 14, 14, 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, 14, 14, 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, 14, 14, 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, 14, 14, 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 ""
}

// 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, 14, 15}
}
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"`
	TargetContextId string              `protobuf:"bytes,5,opt,name=targetContextId,proto3" json:"targetContextId,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, 14, 15, 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
}

func (m *RpcBlockListDuplicateRequest) GetTargetContextId() string {
	if m != nil {
		return m.TargetContextId
	}
	return ""
}

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, 14, 15, 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, 14, 15, 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 RpcBlockListUpdate struct {
}

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

var xxx_messageInfo_RpcBlockListUpdate proto.InternalMessageInfo

type RpcBlockListUpdateRequest 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"`
	// Types that are valid to be assigned to Field:
	//	*RpcBlockListUpdateRequestFieldOfText
	//	*RpcBlockListUpdateRequestFieldOfBackgroundColor
	//	*RpcBlockListUpdateRequestFieldOfAlign
	//	*RpcBlockListUpdateRequestFieldOfFields
	//	*RpcBlockListUpdateRequestFieldOfDivStyle
	//	*RpcBlockListUpdateRequestFieldOfFileStyle
	Field IsRpcBlockListUpdateRequestField `protobuf_oneof:"field"`
}

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

var xxx_messageInfo_RpcBlockListUpdateRequest proto.InternalMessageInfo

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

type RpcBlockListUpdateRequestFieldOfText struct {
	Text *RpcBlockListUpdateRequestText `protobuf:"bytes,3,opt,name=text,proto3,oneof" json:"text,omitempty"`
}
type RpcBlockListUpdateRequestFieldOfBackgroundColor struct {
	BackgroundColor string `protobuf:"bytes,4,opt,name=backgroundColor,proto3,oneof" json:"backgroundColor,omitempty"`
}
type RpcBlockListUpdateRequestFieldOfAlign struct {
	Align model.BlockAlign `protobuf:"varint,5,opt,name=align,proto3,enum=anytype.model.BlockAlign,oneof" json:"align,omitempty"`
}
type RpcBlockListUpdateRequestFieldOfFields struct {
	Fields *types.Struct `protobuf:"bytes,6,opt,name=fields,proto3,oneof" json:"fields,omitempty"`
}
type RpcBlockListUpdateRequestFieldOfDivStyle struct {
	DivStyle model.BlockContentDivStyle `protobuf:"varint,7,opt,name=divStyle,proto3,enum=anytype.model.BlockContentDivStyle,oneof" json:"divStyle,omitempty"`
}
type RpcBlockListUpdateRequestFieldOfFileStyle struct {
	FileStyle model.BlockContentFileStyle `protobuf:"varint,8,opt,name=fileStyle,proto3,enum=anytype.model.BlockContentFileStyle,oneof" json:"fileStyle,omitempty"`
}

func (*RpcBlockListUpdateRequestFieldOfText) IsRpcBlockListUpdateRequestField()            {}
func (*RpcBlockListUpdateRequestFieldOfBackgroundColor) IsRpcBlockListUpdateRequestField() {}
func (*RpcBlockListUpdateRequestFieldOfAlign) IsRpcBlockListUpdateRequestField()           {}
func (*RpcBlockListUpdateRequestFieldOfFields) IsRpcBlockListUpdateRequestField()          {}
func (*RpcBlockListUpdateRequestFieldOfDivStyle) IsRpcBlockListUpdateRequestField()        {}
func (*RpcBlockListUpdateRequestFieldOfFileStyle) IsRpcBlockListUpdateRequestField()       {}

func (m *RpcBlockListUpdateRequest) GetField() IsRpcBlockListUpdateRequestField {
	if m != nil {
		return m.Field
	}
	return nil
}

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

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

func (m *RpcBlockListUpdateRequest) GetText() *RpcBlockListUpdateRequestText {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestFieldOfText); ok {
		return x.Text
	}
	return nil
}

func (m *RpcBlockListUpdateRequest) GetBackgroundColor() string {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestFieldOfBackgroundColor); ok {
		return x.BackgroundColor
	}
	return ""
}

func (m *RpcBlockListUpdateRequest) GetAlign() model.BlockAlign {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestFieldOfAlign); ok {
		return x.Align
	}
	return model.Block_AlignLeft
}

func (m *RpcBlockListUpdateRequest) GetFields() *types.Struct {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestFieldOfFields); ok {
		return x.Fields
	}
	return nil
}

func (m *RpcBlockListUpdateRequest) GetDivStyle() model.BlockContentDivStyle {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestFieldOfDivStyle); ok {
		return x.DivStyle
	}
	return model.BlockContentDiv_Line
}

func (m *RpcBlockListUpdateRequest) GetFileStyle() model.BlockContentFileStyle {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestFieldOfFileStyle); ok {
		return x.FileStyle
	}
	return model.BlockContentFile_Auto
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RpcBlockListUpdateRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RpcBlockListUpdateRequestFieldOfText)(nil),
		(*RpcBlockListUpdateRequestFieldOfBackgroundColor)(nil),
		(*RpcBlockListUpdateRequestFieldOfAlign)(nil),
		(*RpcBlockListUpdateRequestFieldOfFields)(nil),
		(*RpcBlockListUpdateRequestFieldOfDivStyle)(nil),
		(*RpcBlockListUpdateRequestFieldOfFileStyle)(nil),
	}
}

type RpcBlockListUpdateRequestText struct {
	// Types that are valid to be assigned to Field:
	//	*RpcBlockListUpdateRequestTextFieldOfStyle
	//	*RpcBlockListUpdateRequestTextFieldOfColor
	//	*RpcBlockListUpdateRequestTextFieldOfMark
	Field IsRpcBlockListUpdateRequestTextField `protobuf_oneof:"field"`
}

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

var xxx_messageInfo_RpcBlockListUpdateRequestText proto.InternalMessageInfo

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

type RpcBlockListUpdateRequestTextFieldOfStyle struct {
	Style model.BlockContentTextStyle `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.model.BlockContentTextStyle,oneof" json:"style,omitempty"`
}
type RpcBlockListUpdateRequestTextFieldOfColor struct {
	Color string `protobuf:"bytes,2,opt,name=color,proto3,oneof" json:"color,omitempty"`
}
type RpcBlockListUpdateRequestTextFieldOfMark struct {
	Mark *model.BlockContentTextMark `protobuf:"bytes,3,opt,name=mark,proto3,oneof" json:"mark,omitempty"`
}

func (*RpcBlockListUpdateRequestTextFieldOfStyle) IsRpcBlockListUpdateRequestTextField() {}
func (*RpcBlockListUpdateRequestTextFieldOfColor) IsRpcBlockListUpdateRequestTextField() {}
func (*RpcBlockListUpdateRequestTextFieldOfMark) IsRpcBlockListUpdateRequestTextField()  {}

func (m *RpcBlockListUpdateRequestText) GetField() IsRpcBlockListUpdateRequestTextField {
	if m != nil {
		return m.Field
	}
	return nil
}

func (m *RpcBlockListUpdateRequestText) GetStyle() model.BlockContentTextStyle {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestTextFieldOfStyle); ok {
		return x.Style
	}
	return model.BlockContentText_Paragraph
}

func (m *RpcBlockListUpdateRequestText) GetColor() string {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestTextFieldOfColor); ok {
		return x.Color
	}
	return ""
}

func (m *RpcBlockListUpdateRequestText) GetMark() *model.BlockContentTextMark {
	if x, ok := m.GetField().(*RpcBlockListUpdateRequestTextFieldOfMark); ok {
		return x.Mark
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RpcBlockListUpdateRequestText) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RpcBlockListUpdateRequestTextFieldOfStyle)(nil),
		(*RpcBlockListUpdateRequestTextFieldOfColor)(nil),
		(*RpcBlockListUpdateRequestTextFieldOfMark)(nil),
	}
}

type RpcBlockListConvertToObjects struct {
}

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

var xxx_messageInfo_RpcBlockListConvertToObjects proto.InternalMessageInfo

type RpcBlockListConvertToObjectsRequest 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 *RpcBlockListConvertToObjectsRequest) Reset()         { *m = RpcBlockListConvertToObjectsRequest{} }
func (m *RpcBlockListConvertToObjectsRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockListConvertToObjectsRequest) ProtoMessage()    {}
func (*RpcBlockListConvertToObjectsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 17, 0}
}
func (m *RpcBlockListConvertToObjectsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockListConvertToObjectsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockListConvertToObjectsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockListConvertToObjectsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockListConvertToObjectsRequest.Merge(m, src)
}
func (m *RpcBlockListConvertToObjectsRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockListConvertToObjectsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockListConvertToObjectsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockListConvertToObjectsRequest proto.InternalMessageInfo

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

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

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

type RpcBlockListConvertToObjectsResponse struct {
	Error   *RpcBlockListConvertToObjectsResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LinkIds []string                                   `protobuf:"bytes,2,rep,name=linkIds,proto3" json:"linkIds,omitempty"`
	Event   *ResponseEvent                             `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListConvertToObjectsResponse proto.InternalMessageInfo

func (m *RpcBlockListConvertToObjectsResponse) GetError() *RpcBlockListConvertToObjectsResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListConvertToObjectsResponse) GetLinkIds() []string {
	if m != nil {
		return m.LinkIds
	}
	return nil
}

func (m *RpcBlockListConvertToObjectsResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockListConvertToObjectsResponseError proto.InternalMessageInfo

func (m *RpcBlockListConvertToObjectsResponseError) GetCode() RpcBlockListConvertToObjectsResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListConvertToObjectsResponseError_NULL
}

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

type RpcBlockListMoveToExistingObject struct {
}

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

var xxx_messageInfo_RpcBlockListMoveToExistingObject proto.InternalMessageInfo

type RpcBlockListMoveToExistingObjectRequest 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 *RpcBlockListMoveToExistingObjectRequest) Reset() {
	*m = RpcBlockListMoveToExistingObjectRequest{}
}
func (m *RpcBlockListMoveToExistingObjectRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockListMoveToExistingObjectRequest) ProtoMessage()    {}
func (*RpcBlockListMoveToExistingObjectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 18, 0}
}
func (m *RpcBlockListMoveToExistingObjectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockListMoveToExistingObjectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockListMoveToExistingObjectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockListMoveToExistingObjectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockListMoveToExistingObjectRequest.Merge(m, src)
}
func (m *RpcBlockListMoveToExistingObjectRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockListMoveToExistingObjectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockListMoveToExistingObjectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockListMoveToExistingObjectRequest proto.InternalMessageInfo

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

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

func (m *RpcBlockListMoveToExistingObjectRequest) GetTargetContextId() string {
	if m != nil {
		return m.TargetContextId
	}
	return ""
}

func (m *RpcBlockListMoveToExistingObjectRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcBlockListMoveToExistingObjectRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockListMoveToExistingObjectResponse struct {
	Error *RpcBlockListMoveToExistingObjectResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                 `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockListMoveToExistingObjectResponse proto.InternalMessageInfo

func (m *RpcBlockListMoveToExistingObjectResponse) GetError() *RpcBlockListMoveToExistingObjectResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListMoveToExistingObjectResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockListMoveToExistingObjectResponseError proto.InternalMessageInfo

func (m *RpcBlockListMoveToExistingObjectResponseError) GetCode() RpcBlockListMoveToExistingObjectResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListMoveToExistingObjectResponseError_NULL
}

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

type RpcBlockListMoveToNewObject struct {
}

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

var xxx_messageInfo_RpcBlockListMoveToNewObject proto.InternalMessageInfo

type RpcBlockListMoveToNewObjectRequest 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 *RpcBlockListMoveToNewObjectRequest) Reset()         { *m = RpcBlockListMoveToNewObjectRequest{} }
func (m *RpcBlockListMoveToNewObjectRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockListMoveToNewObjectRequest) ProtoMessage()    {}
func (*RpcBlockListMoveToNewObjectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 19, 0}
}
func (m *RpcBlockListMoveToNewObjectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockListMoveToNewObjectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockListMoveToNewObjectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockListMoveToNewObjectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockListMoveToNewObjectRequest.Merge(m, src)
}
func (m *RpcBlockListMoveToNewObjectRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockListMoveToNewObjectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockListMoveToNewObjectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockListMoveToNewObjectRequest proto.InternalMessageInfo

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

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

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

func (m *RpcBlockListMoveToNewObjectRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcBlockListMoveToNewObjectRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockListMoveToNewObjectResponse struct {
	Error  *RpcBlockListMoveToNewObjectResponseError `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 *RpcBlockListMoveToNewObjectResponse) Reset()         { *m = RpcBlockListMoveToNewObjectResponse{} }
func (m *RpcBlockListMoveToNewObjectResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockListMoveToNewObjectResponse) ProtoMessage()    {}
func (*RpcBlockListMoveToNewObjectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 14, 19, 1}
}
func (m *RpcBlockListMoveToNewObjectResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockListMoveToNewObjectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockListMoveToNewObjectResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockListMoveToNewObjectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockListMoveToNewObjectResponse.Merge(m, src)
}
func (m *RpcBlockListMoveToNewObjectResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockListMoveToNewObjectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockListMoveToNewObjectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockListMoveToNewObjectResponse proto.InternalMessageInfo

func (m *RpcBlockListMoveToNewObjectResponse) GetError() *RpcBlockListMoveToNewObjectResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockListMoveToNewObjectResponse) GetLinkId() string {
	if m != nil {
		return m.LinkId
	}
	return ""
}

func (m *RpcBlockListMoveToNewObjectResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockListMoveToNewObjectResponseError proto.InternalMessageInfo

func (m *RpcBlockListMoveToNewObjectResponseError) GetCode() RpcBlockListMoveToNewObjectResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockListMoveToNewObjectResponseError_NULL
}

func (m *RpcBlockListMoveToNewObjectResponseError) 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, 14, 20}
}
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, 14, 20, 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, 14, 20, 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, 14, 20, 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 ""
}

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, 14, 21}
}
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, 14, 21, 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, 14, 21, 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, 14, 21, 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 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, 14, 22}
}
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, 14, 22, 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, 14, 22, 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, 14, 22, 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 RpcBlockLatex struct {
}

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

var xxx_messageInfo_RpcBlockLatex proto.InternalMessageInfo

type RpcBlockLatexSetText struct {
}

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

var xxx_messageInfo_RpcBlockLatexSetText proto.InternalMessageInfo

type RpcBlockLatexSetTextRequest 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 *RpcBlockLatexSetTextRequest) Reset()         { *m = RpcBlockLatexSetTextRequest{} }
func (m *RpcBlockLatexSetTextRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLatexSetTextRequest) ProtoMessage()    {}
func (*RpcBlockLatexSetTextRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 15, 0, 0}
}
func (m *RpcBlockLatexSetTextRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLatexSetTextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLatexSetTextRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLatexSetTextRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLatexSetTextRequest.Merge(m, src)
}
func (m *RpcBlockLatexSetTextRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLatexSetTextRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLatexSetTextRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLatexSetTextRequest proto.InternalMessageInfo

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

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

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

type RpcBlockLatexSetTextResponse struct {
	Error *RpcBlockLatexSetTextResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockLatexSetTextResponse proto.InternalMessageInfo

func (m *RpcBlockLatexSetTextResponse) GetError() *RpcBlockLatexSetTextResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockLatexSetTextResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockLatexSetTextResponseError proto.InternalMessageInfo

func (m *RpcBlockLatexSetTextResponseError) GetCode() RpcBlockLatexSetTextResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockLatexSetTextResponseError_NULL
}

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

type RpcBlockText struct {
}

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

var xxx_messageInfo_RpcBlockText proto.InternalMessageInfo

type RpcBlockTextSetText struct {
}

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

var xxx_messageInfo_RpcBlockTextSetText proto.InternalMessageInfo

type RpcBlockTextSetTextRequest 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 *RpcBlockTextSetTextRequest) Reset()         { *m = RpcBlockTextSetTextRequest{} }
func (m *RpcBlockTextSetTextRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextSetTextRequest) ProtoMessage()    {}
func (*RpcBlockTextSetTextRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 0, 0}
}
func (m *RpcBlockTextSetTextRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextSetTextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextSetTextRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextSetTextRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextSetTextRequest.Merge(m, src)
}
func (m *RpcBlockTextSetTextRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextSetTextRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextSetTextRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextSetTextRequest proto.InternalMessageInfo

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

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

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

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

type RpcBlockTextSetTextResponse struct {
	Error *RpcBlockTextSetTextResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextSetTextResponse proto.InternalMessageInfo

func (m *RpcBlockTextSetTextResponse) GetError() *RpcBlockTextSetTextResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextSetTextResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextSetTextResponseError proto.InternalMessageInfo

func (m *RpcBlockTextSetTextResponseError) GetCode() RpcBlockTextSetTextResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextSetTextResponseError_NULL
}

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

type RpcBlockTextSetColor struct {
}

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

var xxx_messageInfo_RpcBlockTextSetColor proto.InternalMessageInfo

type RpcBlockTextSetColorRequest 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 *RpcBlockTextSetColorRequest) Reset()         { *m = RpcBlockTextSetColorRequest{} }
func (m *RpcBlockTextSetColorRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextSetColorRequest) ProtoMessage()    {}
func (*RpcBlockTextSetColorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 1, 0}
}
func (m *RpcBlockTextSetColorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextSetColorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextSetColorRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextSetColorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextSetColorRequest.Merge(m, src)
}
func (m *RpcBlockTextSetColorRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextSetColorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextSetColorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextSetColorRequest proto.InternalMessageInfo

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

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

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

type RpcBlockTextSetColorResponse struct {
	Error *RpcBlockTextSetColorResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextSetColorResponse proto.InternalMessageInfo

func (m *RpcBlockTextSetColorResponse) GetError() *RpcBlockTextSetColorResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextSetColorResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextSetColorResponseError proto.InternalMessageInfo

func (m *RpcBlockTextSetColorResponseError) GetCode() RpcBlockTextSetColorResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextSetColorResponseError_NULL
}

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

type RpcBlockTextSetMarks struct {
}

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

var xxx_messageInfo_RpcBlockTextSetMarks proto.InternalMessageInfo

// Get marks list in the selected range in text block.
type RpcBlockTextSetMarksGet struct {
}

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

var xxx_messageInfo_RpcBlockTextSetMarksGet proto.InternalMessageInfo

type RpcBlockTextSetMarksGetRequest 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 *RpcBlockTextSetMarksGetRequest) Reset()         { *m = RpcBlockTextSetMarksGetRequest{} }
func (m *RpcBlockTextSetMarksGetRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextSetMarksGetRequest) ProtoMessage()    {}
func (*RpcBlockTextSetMarksGetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 2, 0, 0}
}
func (m *RpcBlockTextSetMarksGetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextSetMarksGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextSetMarksGetRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextSetMarksGetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextSetMarksGetRequest.Merge(m, src)
}
func (m *RpcBlockTextSetMarksGetRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextSetMarksGetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextSetMarksGetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextSetMarksGetRequest proto.InternalMessageInfo

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

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

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

type RpcBlockTextSetMarksGetResponse struct {
	Error *RpcBlockTextSetMarksGetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextSetMarksGetResponse proto.InternalMessageInfo

func (m *RpcBlockTextSetMarksGetResponse) GetError() *RpcBlockTextSetMarksGetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextSetMarksGetResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextSetMarksGetResponseError proto.InternalMessageInfo

func (m *RpcBlockTextSetMarksGetResponseError) GetCode() RpcBlockTextSetMarksGetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextSetMarksGetResponseError_NULL
}

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

type RpcBlockTextSetStyle struct {
}

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

var xxx_messageInfo_RpcBlockTextSetStyle proto.InternalMessageInfo

type RpcBlockTextSetStyleRequest 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 *RpcBlockTextSetStyleRequest) Reset()         { *m = RpcBlockTextSetStyleRequest{} }
func (m *RpcBlockTextSetStyleRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextSetStyleRequest) ProtoMessage()    {}
func (*RpcBlockTextSetStyleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 3, 0}
}
func (m *RpcBlockTextSetStyleRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextSetStyleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextSetStyleRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextSetStyleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextSetStyleRequest.Merge(m, src)
}
func (m *RpcBlockTextSetStyleRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextSetStyleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextSetStyleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextSetStyleRequest proto.InternalMessageInfo

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

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

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

type RpcBlockTextSetStyleResponse struct {
	Error *RpcBlockTextSetStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                     `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextSetStyleResponse proto.InternalMessageInfo

func (m *RpcBlockTextSetStyleResponse) GetError() *RpcBlockTextSetStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextSetStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextSetStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockTextSetStyleResponseError) GetCode() RpcBlockTextSetStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextSetStyleResponseError_NULL
}

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

type RpcBlockTextSetChecked struct {
}

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

var xxx_messageInfo_RpcBlockTextSetChecked proto.InternalMessageInfo

type RpcBlockTextSetCheckedRequest 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 *RpcBlockTextSetCheckedRequest) Reset()         { *m = RpcBlockTextSetCheckedRequest{} }
func (m *RpcBlockTextSetCheckedRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextSetCheckedRequest) ProtoMessage()    {}
func (*RpcBlockTextSetCheckedRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 4, 0}
}
func (m *RpcBlockTextSetCheckedRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextSetCheckedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextSetCheckedRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextSetCheckedRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextSetCheckedRequest.Merge(m, src)
}
func (m *RpcBlockTextSetCheckedRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextSetCheckedRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextSetCheckedRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextSetCheckedRequest proto.InternalMessageInfo

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

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

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

type RpcBlockTextSetCheckedResponse struct {
	Error *RpcBlockTextSetCheckedResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextSetCheckedResponse proto.InternalMessageInfo

func (m *RpcBlockTextSetCheckedResponse) GetError() *RpcBlockTextSetCheckedResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextSetCheckedResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextSetCheckedResponseError proto.InternalMessageInfo

func (m *RpcBlockTextSetCheckedResponseError) GetCode() RpcBlockTextSetCheckedResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextSetCheckedResponseError_NULL
}

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

type RpcBlockTextSetIcon struct {
}

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

var xxx_messageInfo_RpcBlockTextSetIcon proto.InternalMessageInfo

type RpcBlockTextSetIconRequest 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 *RpcBlockTextSetIconRequest) Reset()         { *m = RpcBlockTextSetIconRequest{} }
func (m *RpcBlockTextSetIconRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextSetIconRequest) ProtoMessage()    {}
func (*RpcBlockTextSetIconRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 5, 0}
}
func (m *RpcBlockTextSetIconRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextSetIconRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextSetIconRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextSetIconRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextSetIconRequest.Merge(m, src)
}
func (m *RpcBlockTextSetIconRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextSetIconRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextSetIconRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextSetIconRequest proto.InternalMessageInfo

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

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

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

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

type RpcBlockTextSetIconResponse struct {
	Error *RpcBlockTextSetIconResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextSetIconResponse proto.InternalMessageInfo

func (m *RpcBlockTextSetIconResponse) GetError() *RpcBlockTextSetIconResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextSetIconResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextSetIconResponseError proto.InternalMessageInfo

func (m *RpcBlockTextSetIconResponseError) GetCode() RpcBlockTextSetIconResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextSetIconResponseError_NULL
}

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

type RpcBlockTextListSetStyle struct {
}

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

var xxx_messageInfo_RpcBlockTextListSetStyle proto.InternalMessageInfo

type RpcBlockTextListSetStyleRequest 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 *RpcBlockTextListSetStyleRequest) Reset()         { *m = RpcBlockTextListSetStyleRequest{} }
func (m *RpcBlockTextListSetStyleRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetStyleRequest) ProtoMessage()    {}
func (*RpcBlockTextListSetStyleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 6, 0}
}
func (m *RpcBlockTextListSetStyleRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetStyleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetStyleRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetStyleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetStyleRequest.Merge(m, src)
}
func (m *RpcBlockTextListSetStyleRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetStyleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetStyleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetStyleRequest proto.InternalMessageInfo

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

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

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

type RpcBlockTextListSetStyleResponse struct {
	Error *RpcBlockTextListSetStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

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

var xxx_messageInfo_RpcBlockTextListSetStyleResponse proto.InternalMessageInfo

func (m *RpcBlockTextListSetStyleResponse) GetError() *RpcBlockTextListSetStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextListSetStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockTextListSetStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockTextListSetStyleResponseError) GetCode() RpcBlockTextListSetStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextListSetStyleResponseError_NULL
}

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

type RpcBlockTextListSetColor struct {
}

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

var xxx_messageInfo_RpcBlockTextListSetColor proto.InternalMessageInfo

type RpcBlockTextListSetColorRequest 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 *RpcBlockTextListSetColorRequest) Reset()         { *m = RpcBlockTextListSetColorRequest{} }
func (m *RpcBlockTextListSetColorRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetColorRequest) ProtoMessage()    {}
func (*RpcBlockTextListSetColorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 7, 0}
}
func (m *RpcBlockTextListSetColorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetColorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetColorRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetColorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetColorRequest.Merge(m, src)
}
func (m *RpcBlockTextListSetColorRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetColorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetColorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetColorRequest proto.InternalMessageInfo

func (m *RpcBlockTextListSetColorRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTextListSetColorRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

func (m *RpcBlockTextListSetColorRequest) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

type RpcBlockTextListSetColorResponse struct {
	Error *RpcBlockTextListSetColorResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTextListSetColorResponse) Reset()         { *m = RpcBlockTextListSetColorResponse{} }
func (m *RpcBlockTextListSetColorResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetColorResponse) ProtoMessage()    {}
func (*RpcBlockTextListSetColorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 7, 1}
}
func (m *RpcBlockTextListSetColorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetColorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetColorResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetColorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetColorResponse.Merge(m, src)
}
func (m *RpcBlockTextListSetColorResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetColorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetColorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetColorResponse proto.InternalMessageInfo

func (m *RpcBlockTextListSetColorResponse) GetError() *RpcBlockTextListSetColorResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextListSetColorResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTextListSetColorResponseError struct {
	Code        RpcBlockTextListSetColorResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTextListSetColorResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTextListSetColorResponseError) Reset()         { *m = RpcBlockTextListSetColorResponseError{} }
func (m *RpcBlockTextListSetColorResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetColorResponseError) ProtoMessage()    {}
func (*RpcBlockTextListSetColorResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 7, 1, 0}
}
func (m *RpcBlockTextListSetColorResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetColorResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetColorResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetColorResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetColorResponseError.Merge(m, src)
}
func (m *RpcBlockTextListSetColorResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetColorResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetColorResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetColorResponseError proto.InternalMessageInfo

func (m *RpcBlockTextListSetColorResponseError) GetCode() RpcBlockTextListSetColorResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextListSetColorResponseError_NULL
}

func (m *RpcBlockTextListSetColorResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTextListSetMark struct {
}

func (m *RpcBlockTextListSetMark) Reset()         { *m = RpcBlockTextListSetMark{} }
func (m *RpcBlockTextListSetMark) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetMark) ProtoMessage()    {}
func (*RpcBlockTextListSetMark) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 8}
}
func (m *RpcBlockTextListSetMark) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetMark) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetMark.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetMark) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetMark.Merge(m, src)
}
func (m *RpcBlockTextListSetMark) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetMark) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetMark.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetMark proto.InternalMessageInfo

type RpcBlockTextListSetMarkRequest 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 *RpcBlockTextListSetMarkRequest) Reset()         { *m = RpcBlockTextListSetMarkRequest{} }
func (m *RpcBlockTextListSetMarkRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetMarkRequest) ProtoMessage()    {}
func (*RpcBlockTextListSetMarkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 8, 0}
}
func (m *RpcBlockTextListSetMarkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetMarkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetMarkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetMarkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetMarkRequest.Merge(m, src)
}
func (m *RpcBlockTextListSetMarkRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetMarkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetMarkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetMarkRequest proto.InternalMessageInfo

func (m *RpcBlockTextListSetMarkRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTextListSetMarkRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

func (m *RpcBlockTextListSetMarkRequest) GetMark() *model.BlockContentTextMark {
	if m != nil {
		return m.Mark
	}
	return nil
}

type RpcBlockTextListSetMarkResponse struct {
	Error *RpcBlockTextListSetMarkResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTextListSetMarkResponse) Reset()         { *m = RpcBlockTextListSetMarkResponse{} }
func (m *RpcBlockTextListSetMarkResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetMarkResponse) ProtoMessage()    {}
func (*RpcBlockTextListSetMarkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 8, 1}
}
func (m *RpcBlockTextListSetMarkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetMarkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetMarkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetMarkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetMarkResponse.Merge(m, src)
}
func (m *RpcBlockTextListSetMarkResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetMarkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetMarkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetMarkResponse proto.InternalMessageInfo

func (m *RpcBlockTextListSetMarkResponse) GetError() *RpcBlockTextListSetMarkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextListSetMarkResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTextListSetMarkResponseError struct {
	Code        RpcBlockTextListSetMarkResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTextListSetMarkResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTextListSetMarkResponseError) Reset()         { *m = RpcBlockTextListSetMarkResponseError{} }
func (m *RpcBlockTextListSetMarkResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListSetMarkResponseError) ProtoMessage()    {}
func (*RpcBlockTextListSetMarkResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 8, 1, 0}
}
func (m *RpcBlockTextListSetMarkResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListSetMarkResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListSetMarkResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListSetMarkResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListSetMarkResponseError.Merge(m, src)
}
func (m *RpcBlockTextListSetMarkResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListSetMarkResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListSetMarkResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListSetMarkResponseError proto.InternalMessageInfo

func (m *RpcBlockTextListSetMarkResponseError) GetCode() RpcBlockTextListSetMarkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextListSetMarkResponseError_NULL
}

func (m *RpcBlockTextListSetMarkResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTextListClearStyle struct {
}

func (m *RpcBlockTextListClearStyle) Reset()         { *m = RpcBlockTextListClearStyle{} }
func (m *RpcBlockTextListClearStyle) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearStyle) ProtoMessage()    {}
func (*RpcBlockTextListClearStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 9}
}
func (m *RpcBlockTextListClearStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearStyle.Merge(m, src)
}
func (m *RpcBlockTextListClearStyle) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearStyle proto.InternalMessageInfo

type RpcBlockTextListClearStyleRequest 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 *RpcBlockTextListClearStyleRequest) Reset()         { *m = RpcBlockTextListClearStyleRequest{} }
func (m *RpcBlockTextListClearStyleRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearStyleRequest) ProtoMessage()    {}
func (*RpcBlockTextListClearStyleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 9, 0}
}
func (m *RpcBlockTextListClearStyleRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearStyleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearStyleRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearStyleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearStyleRequest.Merge(m, src)
}
func (m *RpcBlockTextListClearStyleRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearStyleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearStyleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearStyleRequest proto.InternalMessageInfo

func (m *RpcBlockTextListClearStyleRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTextListClearStyleRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type RpcBlockTextListClearStyleResponse struct {
	Error *RpcBlockTextListClearStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                           `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTextListClearStyleResponse) Reset()         { *m = RpcBlockTextListClearStyleResponse{} }
func (m *RpcBlockTextListClearStyleResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearStyleResponse) ProtoMessage()    {}
func (*RpcBlockTextListClearStyleResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 9, 1}
}
func (m *RpcBlockTextListClearStyleResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearStyleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearStyleResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearStyleResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearStyleResponse.Merge(m, src)
}
func (m *RpcBlockTextListClearStyleResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearStyleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearStyleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearStyleResponse proto.InternalMessageInfo

func (m *RpcBlockTextListClearStyleResponse) GetError() *RpcBlockTextListClearStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextListClearStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTextListClearStyleResponseError struct {
	Code        RpcBlockTextListClearStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTextListClearStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                      `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTextListClearStyleResponseError) Reset() {
	*m = RpcBlockTextListClearStyleResponseError{}
}
func (m *RpcBlockTextListClearStyleResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearStyleResponseError) ProtoMessage()    {}
func (*RpcBlockTextListClearStyleResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 9, 1, 0}
}
func (m *RpcBlockTextListClearStyleResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearStyleResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearStyleResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearStyleResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearStyleResponseError.Merge(m, src)
}
func (m *RpcBlockTextListClearStyleResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearStyleResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearStyleResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockTextListClearStyleResponseError) GetCode() RpcBlockTextListClearStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextListClearStyleResponseError_NULL
}

func (m *RpcBlockTextListClearStyleResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTextListClearContent struct {
}

func (m *RpcBlockTextListClearContent) Reset()         { *m = RpcBlockTextListClearContent{} }
func (m *RpcBlockTextListClearContent) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearContent) ProtoMessage()    {}
func (*RpcBlockTextListClearContent) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 10}
}
func (m *RpcBlockTextListClearContent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearContent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearContent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearContent.Merge(m, src)
}
func (m *RpcBlockTextListClearContent) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearContent) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearContent.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearContent proto.InternalMessageInfo

type RpcBlockTextListClearContentRequest 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 *RpcBlockTextListClearContentRequest) Reset()         { *m = RpcBlockTextListClearContentRequest{} }
func (m *RpcBlockTextListClearContentRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearContentRequest) ProtoMessage()    {}
func (*RpcBlockTextListClearContentRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 10, 0}
}
func (m *RpcBlockTextListClearContentRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearContentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearContentRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearContentRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearContentRequest.Merge(m, src)
}
func (m *RpcBlockTextListClearContentRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearContentRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearContentRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearContentRequest proto.InternalMessageInfo

func (m *RpcBlockTextListClearContentRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTextListClearContentRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type RpcBlockTextListClearContentResponse struct {
	Error *RpcBlockTextListClearContentResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                             `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTextListClearContentResponse) Reset()         { *m = RpcBlockTextListClearContentResponse{} }
func (m *RpcBlockTextListClearContentResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTextListClearContentResponse) ProtoMessage()    {}
func (*RpcBlockTextListClearContentResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 10, 1}
}
func (m *RpcBlockTextListClearContentResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearContentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearContentResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearContentResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearContentResponse.Merge(m, src)
}
func (m *RpcBlockTextListClearContentResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearContentResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearContentResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearContentResponse proto.InternalMessageInfo

func (m *RpcBlockTextListClearContentResponse) GetError() *RpcBlockTextListClearContentResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTextListClearContentResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTextListClearContentResponseError struct {
	Code        RpcBlockTextListClearContentResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTextListClearContentResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTextListClearContentResponseError) Reset() {
	*m = RpcBlockTextListClearContentResponseError{}
}
func (m *RpcBlockTextListClearContentResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockTextListClearContentResponseError) ProtoMessage() {}
func (*RpcBlockTextListClearContentResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 16, 10, 1, 0}
}
func (m *RpcBlockTextListClearContentResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTextListClearContentResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTextListClearContentResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTextListClearContentResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTextListClearContentResponseError.Merge(m, src)
}
func (m *RpcBlockTextListClearContentResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTextListClearContentResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTextListClearContentResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTextListClearContentResponseError proto.InternalMessageInfo

func (m *RpcBlockTextListClearContentResponseError) GetCode() RpcBlockTextListClearContentResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTextListClearContentResponseError_NULL
}

func (m *RpcBlockTextListClearContentResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTable struct {
}

func (m *RpcBlockTable) Reset()         { *m = RpcBlockTable{} }
func (m *RpcBlockTable) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTable) ProtoMessage()    {}
func (*RpcBlockTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17}
}
func (m *RpcBlockTable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTable.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTable.Merge(m, src)
}
func (m *RpcBlockTable) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTable) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTable.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTable proto.InternalMessageInfo

type RpcBlockTableCreate struct {
}

func (m *RpcBlockTableCreate) Reset()         { *m = RpcBlockTableCreate{} }
func (m *RpcBlockTableCreate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableCreate) ProtoMessage()    {}
func (*RpcBlockTableCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 0}
}
func (m *RpcBlockTableCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableCreate.Merge(m, src)
}
func (m *RpcBlockTableCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableCreate proto.InternalMessageInfo

type RpcBlockTableCreateRequest 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"`
	Rows          uint32              `protobuf:"varint,4,opt,name=rows,proto3" json:"rows,omitempty"`
	Columns       uint32              `protobuf:"varint,5,opt,name=columns,proto3" json:"columns,omitempty"`
	WithHeaderRow bool                `protobuf:"varint,6,opt,name=withHeaderRow,proto3" json:"withHeaderRow,omitempty"`
}

func (m *RpcBlockTableCreateRequest) Reset()         { *m = RpcBlockTableCreateRequest{} }
func (m *RpcBlockTableCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableCreateRequest) ProtoMessage()    {}
func (*RpcBlockTableCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 0, 0}
}
func (m *RpcBlockTableCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableCreateRequest.Merge(m, src)
}
func (m *RpcBlockTableCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableCreateRequest proto.InternalMessageInfo

func (m *RpcBlockTableCreateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableCreateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableCreateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *RpcBlockTableCreateRequest) GetRows() uint32 {
	if m != nil {
		return m.Rows
	}
	return 0
}

func (m *RpcBlockTableCreateRequest) GetColumns() uint32 {
	if m != nil {
		return m.Columns
	}
	return 0
}

func (m *RpcBlockTableCreateRequest) GetWithHeaderRow() bool {
	if m != nil {
		return m.WithHeaderRow
	}
	return false
}

type RpcBlockTableCreateResponse struct {
	Error   *RpcBlockTableCreateResponseError `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 *RpcBlockTableCreateResponse) Reset()         { *m = RpcBlockTableCreateResponse{} }
func (m *RpcBlockTableCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableCreateResponse) ProtoMessage()    {}
func (*RpcBlockTableCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 0, 1}
}
func (m *RpcBlockTableCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableCreateResponse.Merge(m, src)
}
func (m *RpcBlockTableCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableCreateResponse proto.InternalMessageInfo

func (m *RpcBlockTableCreateResponse) GetError() *RpcBlockTableCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableCreateResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockTableCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableCreateResponseError struct {
	Code        RpcBlockTableCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableCreateResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableCreateResponseError) Reset()         { *m = RpcBlockTableCreateResponseError{} }
func (m *RpcBlockTableCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableCreateResponseError) ProtoMessage()    {}
func (*RpcBlockTableCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 0, 1, 0}
}
func (m *RpcBlockTableCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableCreateResponseError.Merge(m, src)
}
func (m *RpcBlockTableCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableCreateResponseError proto.InternalMessageInfo

func (m *RpcBlockTableCreateResponseError) GetCode() RpcBlockTableCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableCreateResponseError_NULL
}

func (m *RpcBlockTableCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableRowCreate struct {
}

func (m *RpcBlockTableRowCreate) Reset()         { *m = RpcBlockTableRowCreate{} }
func (m *RpcBlockTableRowCreate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowCreate) ProtoMessage()    {}
func (*RpcBlockTableRowCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1}
}
func (m *RpcBlockTableRowCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowCreate.Merge(m, src)
}
func (m *RpcBlockTableRowCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowCreate proto.InternalMessageInfo

type RpcBlockTableRowCreateRequest 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"`
}

func (m *RpcBlockTableRowCreateRequest) Reset()         { *m = RpcBlockTableRowCreateRequest{} }
func (m *RpcBlockTableRowCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowCreateRequest) ProtoMessage()    {}
func (*RpcBlockTableRowCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1, 0}
}
func (m *RpcBlockTableRowCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowCreateRequest.Merge(m, src)
}
func (m *RpcBlockTableRowCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowCreateRequest proto.InternalMessageInfo

func (m *RpcBlockTableRowCreateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableRowCreateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableRowCreateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockTableRowCreateResponse struct {
	Error *RpcBlockTableRowCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableRowCreateResponse) Reset()         { *m = RpcBlockTableRowCreateResponse{} }
func (m *RpcBlockTableRowCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowCreateResponse) ProtoMessage()    {}
func (*RpcBlockTableRowCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1, 1}
}
func (m *RpcBlockTableRowCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowCreateResponse.Merge(m, src)
}
func (m *RpcBlockTableRowCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowCreateResponse proto.InternalMessageInfo

func (m *RpcBlockTableRowCreateResponse) GetError() *RpcBlockTableRowCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableRowCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableRowCreateResponseError struct {
	Code        RpcBlockTableRowCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableRowCreateResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableRowCreateResponseError) Reset()         { *m = RpcBlockTableRowCreateResponseError{} }
func (m *RpcBlockTableRowCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowCreateResponseError) ProtoMessage()    {}
func (*RpcBlockTableRowCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 1, 1, 0}
}
func (m *RpcBlockTableRowCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowCreateResponseError.Merge(m, src)
}
func (m *RpcBlockTableRowCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowCreateResponseError proto.InternalMessageInfo

func (m *RpcBlockTableRowCreateResponseError) GetCode() RpcBlockTableRowCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableRowCreateResponseError_NULL
}

func (m *RpcBlockTableRowCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableRowSetHeader struct {
}

func (m *RpcBlockTableRowSetHeader) Reset()         { *m = RpcBlockTableRowSetHeader{} }
func (m *RpcBlockTableRowSetHeader) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowSetHeader) ProtoMessage()    {}
func (*RpcBlockTableRowSetHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 2}
}
func (m *RpcBlockTableRowSetHeader) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowSetHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowSetHeader.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowSetHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowSetHeader.Merge(m, src)
}
func (m *RpcBlockTableRowSetHeader) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowSetHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowSetHeader.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowSetHeader proto.InternalMessageInfo

type RpcBlockTableRowSetHeaderRequest 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"`
	IsHeader  bool   `protobuf:"varint,3,opt,name=isHeader,proto3" json:"isHeader,omitempty"`
}

func (m *RpcBlockTableRowSetHeaderRequest) Reset()         { *m = RpcBlockTableRowSetHeaderRequest{} }
func (m *RpcBlockTableRowSetHeaderRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowSetHeaderRequest) ProtoMessage()    {}
func (*RpcBlockTableRowSetHeaderRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 2, 0}
}
func (m *RpcBlockTableRowSetHeaderRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowSetHeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowSetHeaderRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowSetHeaderRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowSetHeaderRequest.Merge(m, src)
}
func (m *RpcBlockTableRowSetHeaderRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowSetHeaderRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowSetHeaderRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowSetHeaderRequest proto.InternalMessageInfo

func (m *RpcBlockTableRowSetHeaderRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableRowSetHeaderRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableRowSetHeaderRequest) GetIsHeader() bool {
	if m != nil {
		return m.IsHeader
	}
	return false
}

type RpcBlockTableRowSetHeaderResponse struct {
	Error *RpcBlockTableRowSetHeaderResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableRowSetHeaderResponse) Reset()         { *m = RpcBlockTableRowSetHeaderResponse{} }
func (m *RpcBlockTableRowSetHeaderResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowSetHeaderResponse) ProtoMessage()    {}
func (*RpcBlockTableRowSetHeaderResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 2, 1}
}
func (m *RpcBlockTableRowSetHeaderResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowSetHeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowSetHeaderResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowSetHeaderResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowSetHeaderResponse.Merge(m, src)
}
func (m *RpcBlockTableRowSetHeaderResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowSetHeaderResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowSetHeaderResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowSetHeaderResponse proto.InternalMessageInfo

func (m *RpcBlockTableRowSetHeaderResponse) GetError() *RpcBlockTableRowSetHeaderResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableRowSetHeaderResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableRowSetHeaderResponseError struct {
	Code        RpcBlockTableRowSetHeaderResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableRowSetHeaderResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableRowSetHeaderResponseError) Reset() {
	*m = RpcBlockTableRowSetHeaderResponseError{}
}
func (m *RpcBlockTableRowSetHeaderResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowSetHeaderResponseError) ProtoMessage()    {}
func (*RpcBlockTableRowSetHeaderResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 2, 1, 0}
}
func (m *RpcBlockTableRowSetHeaderResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowSetHeaderResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowSetHeaderResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowSetHeaderResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowSetHeaderResponseError.Merge(m, src)
}
func (m *RpcBlockTableRowSetHeaderResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowSetHeaderResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowSetHeaderResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowSetHeaderResponseError proto.InternalMessageInfo

func (m *RpcBlockTableRowSetHeaderResponseError) GetCode() RpcBlockTableRowSetHeaderResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableRowSetHeaderResponseError_NULL
}

func (m *RpcBlockTableRowSetHeaderResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableRowListFill struct {
}

func (m *RpcBlockTableRowListFill) Reset()         { *m = RpcBlockTableRowListFill{} }
func (m *RpcBlockTableRowListFill) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListFill) ProtoMessage()    {}
func (*RpcBlockTableRowListFill) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 3}
}
func (m *RpcBlockTableRowListFill) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListFill) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListFill.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListFill) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListFill.Merge(m, src)
}
func (m *RpcBlockTableRowListFill) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListFill) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListFill.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListFill proto.InternalMessageInfo

type RpcBlockTableRowListFillRequest 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 *RpcBlockTableRowListFillRequest) Reset()         { *m = RpcBlockTableRowListFillRequest{} }
func (m *RpcBlockTableRowListFillRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListFillRequest) ProtoMessage()    {}
func (*RpcBlockTableRowListFillRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 3, 0}
}
func (m *RpcBlockTableRowListFillRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListFillRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListFillRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListFillRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListFillRequest.Merge(m, src)
}
func (m *RpcBlockTableRowListFillRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListFillRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListFillRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListFillRequest proto.InternalMessageInfo

func (m *RpcBlockTableRowListFillRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableRowListFillRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type RpcBlockTableRowListFillResponse struct {
	Error *RpcBlockTableRowListFillResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableRowListFillResponse) Reset()         { *m = RpcBlockTableRowListFillResponse{} }
func (m *RpcBlockTableRowListFillResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListFillResponse) ProtoMessage()    {}
func (*RpcBlockTableRowListFillResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 3, 1}
}
func (m *RpcBlockTableRowListFillResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListFillResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListFillResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListFillResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListFillResponse.Merge(m, src)
}
func (m *RpcBlockTableRowListFillResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListFillResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListFillResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListFillResponse proto.InternalMessageInfo

func (m *RpcBlockTableRowListFillResponse) GetError() *RpcBlockTableRowListFillResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableRowListFillResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableRowListFillResponseError struct {
	Code        RpcBlockTableRowListFillResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableRowListFillResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableRowListFillResponseError) Reset()         { *m = RpcBlockTableRowListFillResponseError{} }
func (m *RpcBlockTableRowListFillResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListFillResponseError) ProtoMessage()    {}
func (*RpcBlockTableRowListFillResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 3, 1, 0}
}
func (m *RpcBlockTableRowListFillResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListFillResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListFillResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListFillResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListFillResponseError.Merge(m, src)
}
func (m *RpcBlockTableRowListFillResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListFillResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListFillResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListFillResponseError proto.InternalMessageInfo

func (m *RpcBlockTableRowListFillResponseError) GetCode() RpcBlockTableRowListFillResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableRowListFillResponseError_NULL
}

func (m *RpcBlockTableRowListFillResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableRowListClean struct {
}

func (m *RpcBlockTableRowListClean) Reset()         { *m = RpcBlockTableRowListClean{} }
func (m *RpcBlockTableRowListClean) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListClean) ProtoMessage()    {}
func (*RpcBlockTableRowListClean) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 4}
}
func (m *RpcBlockTableRowListClean) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListClean) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListClean.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListClean) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListClean.Merge(m, src)
}
func (m *RpcBlockTableRowListClean) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListClean) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListClean.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListClean proto.InternalMessageInfo

type RpcBlockTableRowListCleanRequest 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 *RpcBlockTableRowListCleanRequest) Reset()         { *m = RpcBlockTableRowListCleanRequest{} }
func (m *RpcBlockTableRowListCleanRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListCleanRequest) ProtoMessage()    {}
func (*RpcBlockTableRowListCleanRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 4, 0}
}
func (m *RpcBlockTableRowListCleanRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListCleanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListCleanRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListCleanRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListCleanRequest.Merge(m, src)
}
func (m *RpcBlockTableRowListCleanRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListCleanRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListCleanRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListCleanRequest proto.InternalMessageInfo

func (m *RpcBlockTableRowListCleanRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableRowListCleanRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type RpcBlockTableRowListCleanResponse struct {
	Error *RpcBlockTableRowListCleanResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableRowListCleanResponse) Reset()         { *m = RpcBlockTableRowListCleanResponse{} }
func (m *RpcBlockTableRowListCleanResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListCleanResponse) ProtoMessage()    {}
func (*RpcBlockTableRowListCleanResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 4, 1}
}
func (m *RpcBlockTableRowListCleanResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListCleanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListCleanResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListCleanResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListCleanResponse.Merge(m, src)
}
func (m *RpcBlockTableRowListCleanResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListCleanResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListCleanResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListCleanResponse proto.InternalMessageInfo

func (m *RpcBlockTableRowListCleanResponse) GetError() *RpcBlockTableRowListCleanResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableRowListCleanResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableRowListCleanResponseError struct {
	Code        RpcBlockTableRowListCleanResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableRowListCleanResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableRowListCleanResponseError) Reset() {
	*m = RpcBlockTableRowListCleanResponseError{}
}
func (m *RpcBlockTableRowListCleanResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowListCleanResponseError) ProtoMessage()    {}
func (*RpcBlockTableRowListCleanResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 4, 1, 0}
}
func (m *RpcBlockTableRowListCleanResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowListCleanResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowListCleanResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowListCleanResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowListCleanResponseError.Merge(m, src)
}
func (m *RpcBlockTableRowListCleanResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowListCleanResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowListCleanResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowListCleanResponseError proto.InternalMessageInfo

func (m *RpcBlockTableRowListCleanResponseError) GetCode() RpcBlockTableRowListCleanResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableRowListCleanResponseError_NULL
}

func (m *RpcBlockTableRowListCleanResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableColumnListFill struct {
}

func (m *RpcBlockTableColumnListFill) Reset()         { *m = RpcBlockTableColumnListFill{} }
func (m *RpcBlockTableColumnListFill) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnListFill) ProtoMessage()    {}
func (*RpcBlockTableColumnListFill) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 5}
}
func (m *RpcBlockTableColumnListFill) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnListFill) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnListFill.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnListFill) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnListFill.Merge(m, src)
}
func (m *RpcBlockTableColumnListFill) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnListFill) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnListFill.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnListFill proto.InternalMessageInfo

type RpcBlockTableColumnListFillRequest 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 *RpcBlockTableColumnListFillRequest) Reset()         { *m = RpcBlockTableColumnListFillRequest{} }
func (m *RpcBlockTableColumnListFillRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnListFillRequest) ProtoMessage()    {}
func (*RpcBlockTableColumnListFillRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 5, 0}
}
func (m *RpcBlockTableColumnListFillRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnListFillRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnListFillRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnListFillRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnListFillRequest.Merge(m, src)
}
func (m *RpcBlockTableColumnListFillRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnListFillRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnListFillRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnListFillRequest proto.InternalMessageInfo

func (m *RpcBlockTableColumnListFillRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableColumnListFillRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

type RpcBlockTableColumnListFillResponse struct {
	Error *RpcBlockTableColumnListFillResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                            `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableColumnListFillResponse) Reset()         { *m = RpcBlockTableColumnListFillResponse{} }
func (m *RpcBlockTableColumnListFillResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnListFillResponse) ProtoMessage()    {}
func (*RpcBlockTableColumnListFillResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 5, 1}
}
func (m *RpcBlockTableColumnListFillResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnListFillResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnListFillResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnListFillResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnListFillResponse.Merge(m, src)
}
func (m *RpcBlockTableColumnListFillResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnListFillResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnListFillResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnListFillResponse proto.InternalMessageInfo

func (m *RpcBlockTableColumnListFillResponse) GetError() *RpcBlockTableColumnListFillResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableColumnListFillResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableColumnListFillResponseError struct {
	Code        RpcBlockTableColumnListFillResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableColumnListFillResponseErrorCode" json:"code,omitempty"`
	Description string                                       `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableColumnListFillResponseError) Reset() {
	*m = RpcBlockTableColumnListFillResponseError{}
}
func (m *RpcBlockTableColumnListFillResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnListFillResponseError) ProtoMessage()    {}
func (*RpcBlockTableColumnListFillResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 5, 1, 0}
}
func (m *RpcBlockTableColumnListFillResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnListFillResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnListFillResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnListFillResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnListFillResponseError.Merge(m, src)
}
func (m *RpcBlockTableColumnListFillResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnListFillResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnListFillResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnListFillResponseError proto.InternalMessageInfo

func (m *RpcBlockTableColumnListFillResponseError) GetCode() RpcBlockTableColumnListFillResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableColumnListFillResponseError_NULL
}

func (m *RpcBlockTableColumnListFillResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableColumnCreate struct {
}

func (m *RpcBlockTableColumnCreate) Reset()         { *m = RpcBlockTableColumnCreate{} }
func (m *RpcBlockTableColumnCreate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnCreate) ProtoMessage()    {}
func (*RpcBlockTableColumnCreate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 6}
}
func (m *RpcBlockTableColumnCreate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnCreate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnCreate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnCreate.Merge(m, src)
}
func (m *RpcBlockTableColumnCreate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnCreate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnCreate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnCreate proto.InternalMessageInfo

type RpcBlockTableColumnCreateRequest 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"`
}

func (m *RpcBlockTableColumnCreateRequest) Reset()         { *m = RpcBlockTableColumnCreateRequest{} }
func (m *RpcBlockTableColumnCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnCreateRequest) ProtoMessage()    {}
func (*RpcBlockTableColumnCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 6, 0}
}
func (m *RpcBlockTableColumnCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnCreateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnCreateRequest.Merge(m, src)
}
func (m *RpcBlockTableColumnCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnCreateRequest proto.InternalMessageInfo

func (m *RpcBlockTableColumnCreateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableColumnCreateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableColumnCreateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockTableColumnCreateResponse struct {
	Error *RpcBlockTableColumnCreateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableColumnCreateResponse) Reset()         { *m = RpcBlockTableColumnCreateResponse{} }
func (m *RpcBlockTableColumnCreateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnCreateResponse) ProtoMessage()    {}
func (*RpcBlockTableColumnCreateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 6, 1}
}
func (m *RpcBlockTableColumnCreateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnCreateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnCreateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnCreateResponse.Merge(m, src)
}
func (m *RpcBlockTableColumnCreateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnCreateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnCreateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnCreateResponse proto.InternalMessageInfo

func (m *RpcBlockTableColumnCreateResponse) GetError() *RpcBlockTableColumnCreateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableColumnCreateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableColumnCreateResponseError struct {
	Code        RpcBlockTableColumnCreateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableColumnCreateResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableColumnCreateResponseError) Reset() {
	*m = RpcBlockTableColumnCreateResponseError{}
}
func (m *RpcBlockTableColumnCreateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnCreateResponseError) ProtoMessage()    {}
func (*RpcBlockTableColumnCreateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 6, 1, 0}
}
func (m *RpcBlockTableColumnCreateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnCreateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnCreateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnCreateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnCreateResponseError.Merge(m, src)
}
func (m *RpcBlockTableColumnCreateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnCreateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnCreateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnCreateResponseError proto.InternalMessageInfo

func (m *RpcBlockTableColumnCreateResponseError) GetCode() RpcBlockTableColumnCreateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableColumnCreateResponseError_NULL
}

func (m *RpcBlockTableColumnCreateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableRowDelete struct {
}

func (m *RpcBlockTableRowDelete) Reset()         { *m = RpcBlockTableRowDelete{} }
func (m *RpcBlockTableRowDelete) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDelete) ProtoMessage()    {}
func (*RpcBlockTableRowDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 7}
}
func (m *RpcBlockTableRowDelete) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDelete.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDelete.Merge(m, src)
}
func (m *RpcBlockTableRowDelete) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDelete.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDelete proto.InternalMessageInfo

type RpcBlockTableRowDeleteRequest 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"`
}

func (m *RpcBlockTableRowDeleteRequest) Reset()         { *m = RpcBlockTableRowDeleteRequest{} }
func (m *RpcBlockTableRowDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDeleteRequest) ProtoMessage()    {}
func (*RpcBlockTableRowDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 7, 0}
}
func (m *RpcBlockTableRowDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDeleteRequest.Merge(m, src)
}
func (m *RpcBlockTableRowDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDeleteRequest proto.InternalMessageInfo

func (m *RpcBlockTableRowDeleteRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableRowDeleteRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

type RpcBlockTableRowDeleteResponse struct {
	Error *RpcBlockTableRowDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                       `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableRowDeleteResponse) Reset()         { *m = RpcBlockTableRowDeleteResponse{} }
func (m *RpcBlockTableRowDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDeleteResponse) ProtoMessage()    {}
func (*RpcBlockTableRowDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 7, 1}
}
func (m *RpcBlockTableRowDeleteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDeleteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDeleteResponse.Merge(m, src)
}
func (m *RpcBlockTableRowDeleteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockTableRowDeleteResponse) GetError() *RpcBlockTableRowDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableRowDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableRowDeleteResponseError struct {
	Code        RpcBlockTableRowDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableRowDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                  `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableRowDeleteResponseError) Reset()         { *m = RpcBlockTableRowDeleteResponseError{} }
func (m *RpcBlockTableRowDeleteResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDeleteResponseError) ProtoMessage()    {}
func (*RpcBlockTableRowDeleteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 7, 1, 0}
}
func (m *RpcBlockTableRowDeleteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDeleteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDeleteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDeleteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDeleteResponseError.Merge(m, src)
}
func (m *RpcBlockTableRowDeleteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDeleteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDeleteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockTableRowDeleteResponseError) GetCode() RpcBlockTableRowDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableRowDeleteResponseError_NULL
}

func (m *RpcBlockTableRowDeleteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableColumnDelete struct {
}

func (m *RpcBlockTableColumnDelete) Reset()         { *m = RpcBlockTableColumnDelete{} }
func (m *RpcBlockTableColumnDelete) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDelete) ProtoMessage()    {}
func (*RpcBlockTableColumnDelete) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 8}
}
func (m *RpcBlockTableColumnDelete) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDelete.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDelete) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDelete.Merge(m, src)
}
func (m *RpcBlockTableColumnDelete) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDelete) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDelete.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDelete proto.InternalMessageInfo

type RpcBlockTableColumnDeleteRequest 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"`
}

func (m *RpcBlockTableColumnDeleteRequest) Reset()         { *m = RpcBlockTableColumnDeleteRequest{} }
func (m *RpcBlockTableColumnDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDeleteRequest) ProtoMessage()    {}
func (*RpcBlockTableColumnDeleteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 8, 0}
}
func (m *RpcBlockTableColumnDeleteRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDeleteRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDeleteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDeleteRequest.Merge(m, src)
}
func (m *RpcBlockTableColumnDeleteRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDeleteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDeleteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDeleteRequest proto.InternalMessageInfo

func (m *RpcBlockTableColumnDeleteRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableColumnDeleteRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

type RpcBlockTableColumnDeleteResponse struct {
	Error *RpcBlockTableColumnDeleteResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableColumnDeleteResponse) Reset()         { *m = RpcBlockTableColumnDeleteResponse{} }
func (m *RpcBlockTableColumnDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDeleteResponse) ProtoMessage()    {}
func (*RpcBlockTableColumnDeleteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 8, 1}
}
func (m *RpcBlockTableColumnDeleteResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDeleteResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDeleteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDeleteResponse.Merge(m, src)
}
func (m *RpcBlockTableColumnDeleteResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDeleteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDeleteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDeleteResponse proto.InternalMessageInfo

func (m *RpcBlockTableColumnDeleteResponse) GetError() *RpcBlockTableColumnDeleteResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableColumnDeleteResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableColumnDeleteResponseError struct {
	Code        RpcBlockTableColumnDeleteResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableColumnDeleteResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableColumnDeleteResponseError) Reset() {
	*m = RpcBlockTableColumnDeleteResponseError{}
}
func (m *RpcBlockTableColumnDeleteResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDeleteResponseError) ProtoMessage()    {}
func (*RpcBlockTableColumnDeleteResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 8, 1, 0}
}
func (m *RpcBlockTableColumnDeleteResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDeleteResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDeleteResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDeleteResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDeleteResponseError.Merge(m, src)
}
func (m *RpcBlockTableColumnDeleteResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDeleteResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDeleteResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDeleteResponseError proto.InternalMessageInfo

func (m *RpcBlockTableColumnDeleteResponseError) GetCode() RpcBlockTableColumnDeleteResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableColumnDeleteResponseError_NULL
}

func (m *RpcBlockTableColumnDeleteResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableColumnMove struct {
}

func (m *RpcBlockTableColumnMove) Reset()         { *m = RpcBlockTableColumnMove{} }
func (m *RpcBlockTableColumnMove) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnMove) ProtoMessage()    {}
func (*RpcBlockTableColumnMove) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 9}
}
func (m *RpcBlockTableColumnMove) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnMove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnMove.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnMove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnMove.Merge(m, src)
}
func (m *RpcBlockTableColumnMove) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnMove) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnMove.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnMove proto.InternalMessageInfo

type RpcBlockTableColumnMoveRequest 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"`
	DropTargetId string              `protobuf:"bytes,3,opt,name=dropTargetId,proto3" json:"dropTargetId,omitempty"`
	Position     model.BlockPosition `protobuf:"varint,4,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

func (m *RpcBlockTableColumnMoveRequest) Reset()         { *m = RpcBlockTableColumnMoveRequest{} }
func (m *RpcBlockTableColumnMoveRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnMoveRequest) ProtoMessage()    {}
func (*RpcBlockTableColumnMoveRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 9, 0}
}
func (m *RpcBlockTableColumnMoveRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnMoveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnMoveRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnMoveRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnMoveRequest.Merge(m, src)
}
func (m *RpcBlockTableColumnMoveRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnMoveRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnMoveRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnMoveRequest proto.InternalMessageInfo

func (m *RpcBlockTableColumnMoveRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableColumnMoveRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableColumnMoveRequest) GetDropTargetId() string {
	if m != nil {
		return m.DropTargetId
	}
	return ""
}

func (m *RpcBlockTableColumnMoveRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockTableColumnMoveResponse struct {
	Error *RpcBlockTableColumnMoveResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableColumnMoveResponse) Reset()         { *m = RpcBlockTableColumnMoveResponse{} }
func (m *RpcBlockTableColumnMoveResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnMoveResponse) ProtoMessage()    {}
func (*RpcBlockTableColumnMoveResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 9, 1}
}
func (m *RpcBlockTableColumnMoveResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnMoveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnMoveResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnMoveResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnMoveResponse.Merge(m, src)
}
func (m *RpcBlockTableColumnMoveResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnMoveResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnMoveResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnMoveResponse proto.InternalMessageInfo

func (m *RpcBlockTableColumnMoveResponse) GetError() *RpcBlockTableColumnMoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableColumnMoveResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableColumnMoveResponseError struct {
	Code        RpcBlockTableColumnMoveResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableColumnMoveResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableColumnMoveResponseError) Reset()         { *m = RpcBlockTableColumnMoveResponseError{} }
func (m *RpcBlockTableColumnMoveResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnMoveResponseError) ProtoMessage()    {}
func (*RpcBlockTableColumnMoveResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 9, 1, 0}
}
func (m *RpcBlockTableColumnMoveResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnMoveResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnMoveResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnMoveResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnMoveResponseError.Merge(m, src)
}
func (m *RpcBlockTableColumnMoveResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnMoveResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnMoveResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnMoveResponseError proto.InternalMessageInfo

func (m *RpcBlockTableColumnMoveResponseError) GetCode() RpcBlockTableColumnMoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableColumnMoveResponseError_NULL
}

func (m *RpcBlockTableColumnMoveResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableRowDuplicate struct {
}

func (m *RpcBlockTableRowDuplicate) Reset()         { *m = RpcBlockTableRowDuplicate{} }
func (m *RpcBlockTableRowDuplicate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDuplicate) ProtoMessage()    {}
func (*RpcBlockTableRowDuplicate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 10}
}
func (m *RpcBlockTableRowDuplicate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDuplicate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDuplicate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDuplicate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDuplicate.Merge(m, src)
}
func (m *RpcBlockTableRowDuplicate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDuplicate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDuplicate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDuplicate proto.InternalMessageInfo

type RpcBlockTableRowDuplicateRequest 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"`
	BlockId   string              `protobuf:"bytes,3,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Position  model.BlockPosition `protobuf:"varint,4,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

func (m *RpcBlockTableRowDuplicateRequest) Reset()         { *m = RpcBlockTableRowDuplicateRequest{} }
func (m *RpcBlockTableRowDuplicateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDuplicateRequest) ProtoMessage()    {}
func (*RpcBlockTableRowDuplicateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 10, 0}
}
func (m *RpcBlockTableRowDuplicateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDuplicateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDuplicateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDuplicateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDuplicateRequest.Merge(m, src)
}
func (m *RpcBlockTableRowDuplicateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDuplicateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDuplicateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDuplicateRequest proto.InternalMessageInfo

func (m *RpcBlockTableRowDuplicateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableRowDuplicateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableRowDuplicateRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockTableRowDuplicateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockTableRowDuplicateResponse struct {
	Error *RpcBlockTableRowDuplicateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                          `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableRowDuplicateResponse) Reset()         { *m = RpcBlockTableRowDuplicateResponse{} }
func (m *RpcBlockTableRowDuplicateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDuplicateResponse) ProtoMessage()    {}
func (*RpcBlockTableRowDuplicateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 10, 1}
}
func (m *RpcBlockTableRowDuplicateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDuplicateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDuplicateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDuplicateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDuplicateResponse.Merge(m, src)
}
func (m *RpcBlockTableRowDuplicateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDuplicateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDuplicateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDuplicateResponse proto.InternalMessageInfo

func (m *RpcBlockTableRowDuplicateResponse) GetError() *RpcBlockTableRowDuplicateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableRowDuplicateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableRowDuplicateResponseError struct {
	Code        RpcBlockTableRowDuplicateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableRowDuplicateResponseErrorCode" json:"code,omitempty"`
	Description string                                     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableRowDuplicateResponseError) Reset() {
	*m = RpcBlockTableRowDuplicateResponseError{}
}
func (m *RpcBlockTableRowDuplicateResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableRowDuplicateResponseError) ProtoMessage()    {}
func (*RpcBlockTableRowDuplicateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 10, 1, 0}
}
func (m *RpcBlockTableRowDuplicateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableRowDuplicateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableRowDuplicateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableRowDuplicateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableRowDuplicateResponseError.Merge(m, src)
}
func (m *RpcBlockTableRowDuplicateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableRowDuplicateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableRowDuplicateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableRowDuplicateResponseError proto.InternalMessageInfo

func (m *RpcBlockTableRowDuplicateResponseError) GetCode() RpcBlockTableRowDuplicateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableRowDuplicateResponseError_NULL
}

func (m *RpcBlockTableRowDuplicateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableColumnDuplicate struct {
}

func (m *RpcBlockTableColumnDuplicate) Reset()         { *m = RpcBlockTableColumnDuplicate{} }
func (m *RpcBlockTableColumnDuplicate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDuplicate) ProtoMessage()    {}
func (*RpcBlockTableColumnDuplicate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 11}
}
func (m *RpcBlockTableColumnDuplicate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDuplicate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDuplicate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDuplicate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDuplicate.Merge(m, src)
}
func (m *RpcBlockTableColumnDuplicate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDuplicate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDuplicate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDuplicate proto.InternalMessageInfo

type RpcBlockTableColumnDuplicateRequest 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"`
	BlockId   string              `protobuf:"bytes,3,opt,name=blockId,proto3" json:"blockId,omitempty"`
	Position  model.BlockPosition `protobuf:"varint,4,opt,name=position,proto3,enum=anytype.model.BlockPosition" json:"position,omitempty"`
}

func (m *RpcBlockTableColumnDuplicateRequest) Reset()         { *m = RpcBlockTableColumnDuplicateRequest{} }
func (m *RpcBlockTableColumnDuplicateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDuplicateRequest) ProtoMessage()    {}
func (*RpcBlockTableColumnDuplicateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 11, 0}
}
func (m *RpcBlockTableColumnDuplicateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDuplicateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDuplicateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDuplicateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDuplicateRequest.Merge(m, src)
}
func (m *RpcBlockTableColumnDuplicateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDuplicateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDuplicateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDuplicateRequest proto.InternalMessageInfo

func (m *RpcBlockTableColumnDuplicateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableColumnDuplicateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableColumnDuplicateRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockTableColumnDuplicateRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

type RpcBlockTableColumnDuplicateResponse struct {
	Error   *RpcBlockTableColumnDuplicateResponseError `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 *RpcBlockTableColumnDuplicateResponse) Reset()         { *m = RpcBlockTableColumnDuplicateResponse{} }
func (m *RpcBlockTableColumnDuplicateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableColumnDuplicateResponse) ProtoMessage()    {}
func (*RpcBlockTableColumnDuplicateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 11, 1}
}
func (m *RpcBlockTableColumnDuplicateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDuplicateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDuplicateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDuplicateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDuplicateResponse.Merge(m, src)
}
func (m *RpcBlockTableColumnDuplicateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDuplicateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDuplicateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDuplicateResponse proto.InternalMessageInfo

func (m *RpcBlockTableColumnDuplicateResponse) GetError() *RpcBlockTableColumnDuplicateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableColumnDuplicateResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockTableColumnDuplicateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableColumnDuplicateResponseError struct {
	Code        RpcBlockTableColumnDuplicateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableColumnDuplicateResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableColumnDuplicateResponseError) Reset() {
	*m = RpcBlockTableColumnDuplicateResponseError{}
}
func (m *RpcBlockTableColumnDuplicateResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockTableColumnDuplicateResponseError) ProtoMessage() {}
func (*RpcBlockTableColumnDuplicateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 11, 1, 0}
}
func (m *RpcBlockTableColumnDuplicateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableColumnDuplicateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableColumnDuplicateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableColumnDuplicateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableColumnDuplicateResponseError.Merge(m, src)
}
func (m *RpcBlockTableColumnDuplicateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableColumnDuplicateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableColumnDuplicateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableColumnDuplicateResponseError proto.InternalMessageInfo

func (m *RpcBlockTableColumnDuplicateResponseError) GetCode() RpcBlockTableColumnDuplicateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableColumnDuplicateResponseError_NULL
}

func (m *RpcBlockTableColumnDuplicateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableExpand struct {
}

func (m *RpcBlockTableExpand) Reset()         { *m = RpcBlockTableExpand{} }
func (m *RpcBlockTableExpand) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableExpand) ProtoMessage()    {}
func (*RpcBlockTableExpand) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 12}
}
func (m *RpcBlockTableExpand) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableExpand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableExpand.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableExpand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableExpand.Merge(m, src)
}
func (m *RpcBlockTableExpand) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableExpand) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableExpand.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableExpand proto.InternalMessageInfo

type RpcBlockTableExpandRequest 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"`
	Columns   uint32 `protobuf:"varint,3,opt,name=columns,proto3" json:"columns,omitempty"`
	Rows      uint32 `protobuf:"varint,4,opt,name=rows,proto3" json:"rows,omitempty"`
}

func (m *RpcBlockTableExpandRequest) Reset()         { *m = RpcBlockTableExpandRequest{} }
func (m *RpcBlockTableExpandRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableExpandRequest) ProtoMessage()    {}
func (*RpcBlockTableExpandRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 12, 0}
}
func (m *RpcBlockTableExpandRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableExpandRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableExpandRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableExpandRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableExpandRequest.Merge(m, src)
}
func (m *RpcBlockTableExpandRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableExpandRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableExpandRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableExpandRequest proto.InternalMessageInfo

func (m *RpcBlockTableExpandRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableExpandRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockTableExpandRequest) GetColumns() uint32 {
	if m != nil {
		return m.Columns
	}
	return 0
}

func (m *RpcBlockTableExpandRequest) GetRows() uint32 {
	if m != nil {
		return m.Rows
	}
	return 0
}

type RpcBlockTableExpandResponse struct {
	Error *RpcBlockTableExpandResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableExpandResponse) Reset()         { *m = RpcBlockTableExpandResponse{} }
func (m *RpcBlockTableExpandResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableExpandResponse) ProtoMessage()    {}
func (*RpcBlockTableExpandResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 12, 1}
}
func (m *RpcBlockTableExpandResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableExpandResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableExpandResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableExpandResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableExpandResponse.Merge(m, src)
}
func (m *RpcBlockTableExpandResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableExpandResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableExpandResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableExpandResponse proto.InternalMessageInfo

func (m *RpcBlockTableExpandResponse) GetError() *RpcBlockTableExpandResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableExpandResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableExpandResponseError struct {
	Code        RpcBlockTableExpandResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableExpandResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableExpandResponseError) Reset()         { *m = RpcBlockTableExpandResponseError{} }
func (m *RpcBlockTableExpandResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableExpandResponseError) ProtoMessage()    {}
func (*RpcBlockTableExpandResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 12, 1, 0}
}
func (m *RpcBlockTableExpandResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableExpandResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableExpandResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableExpandResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableExpandResponseError.Merge(m, src)
}
func (m *RpcBlockTableExpandResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableExpandResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableExpandResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableExpandResponseError proto.InternalMessageInfo

func (m *RpcBlockTableExpandResponseError) GetCode() RpcBlockTableExpandResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableExpandResponseError_NULL
}

func (m *RpcBlockTableExpandResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockTableSort struct {
}

func (m *RpcBlockTableSort) Reset()         { *m = RpcBlockTableSort{} }
func (m *RpcBlockTableSort) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableSort) ProtoMessage()    {}
func (*RpcBlockTableSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 13}
}
func (m *RpcBlockTableSort) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableSort.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableSort.Merge(m, src)
}
func (m *RpcBlockTableSort) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableSort) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableSort.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableSort proto.InternalMessageInfo

type RpcBlockTableSortRequest struct {
	ContextId string                             `protobuf:"bytes,1,opt,name=contextId,proto3" json:"contextId,omitempty"`
	ColumnId  string                             `protobuf:"bytes,2,opt,name=columnId,proto3" json:"columnId,omitempty"`
	Type      model.BlockContentDataviewSortType `protobuf:"varint,3,opt,name=type,proto3,enum=anytype.model.BlockContentDataviewSortType" json:"type,omitempty"`
}

func (m *RpcBlockTableSortRequest) Reset()         { *m = RpcBlockTableSortRequest{} }
func (m *RpcBlockTableSortRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableSortRequest) ProtoMessage()    {}
func (*RpcBlockTableSortRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 13, 0}
}
func (m *RpcBlockTableSortRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableSortRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableSortRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableSortRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableSortRequest.Merge(m, src)
}
func (m *RpcBlockTableSortRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableSortRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableSortRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableSortRequest proto.InternalMessageInfo

func (m *RpcBlockTableSortRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockTableSortRequest) GetColumnId() string {
	if m != nil {
		return m.ColumnId
	}
	return ""
}

func (m *RpcBlockTableSortRequest) GetType() model.BlockContentDataviewSortType {
	if m != nil {
		return m.Type
	}
	return model.BlockContentDataviewSort_Asc
}

type RpcBlockTableSortResponse struct {
	Error *RpcBlockTableSortResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                  `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockTableSortResponse) Reset()         { *m = RpcBlockTableSortResponse{} }
func (m *RpcBlockTableSortResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableSortResponse) ProtoMessage()    {}
func (*RpcBlockTableSortResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 13, 1}
}
func (m *RpcBlockTableSortResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableSortResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableSortResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableSortResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableSortResponse.Merge(m, src)
}
func (m *RpcBlockTableSortResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableSortResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableSortResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableSortResponse proto.InternalMessageInfo

func (m *RpcBlockTableSortResponse) GetError() *RpcBlockTableSortResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockTableSortResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockTableSortResponseError struct {
	Code        RpcBlockTableSortResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockTableSortResponseErrorCode" json:"code,omitempty"`
	Description string                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockTableSortResponseError) Reset()         { *m = RpcBlockTableSortResponseError{} }
func (m *RpcBlockTableSortResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockTableSortResponseError) ProtoMessage()    {}
func (*RpcBlockTableSortResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 17, 13, 1, 0}
}
func (m *RpcBlockTableSortResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockTableSortResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockTableSortResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockTableSortResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockTableSortResponseError.Merge(m, src)
}
func (m *RpcBlockTableSortResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockTableSortResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockTableSortResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockTableSortResponseError proto.InternalMessageInfo

func (m *RpcBlockTableSortResponseError) GetCode() RpcBlockTableSortResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockTableSortResponseError_NULL
}

func (m *RpcBlockTableSortResponseError) 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, 18}
}
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 RpcBlockFileSetName struct {
}

func (m *RpcBlockFileSetName) Reset()         { *m = RpcBlockFileSetName{} }
func (m *RpcBlockFileSetName) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileSetName) ProtoMessage()    {}
func (*RpcBlockFileSetName) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0}
}
func (m *RpcBlockFileSetName) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileSetName) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileSetName.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileSetName) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileSetName.Merge(m, src)
}
func (m *RpcBlockFileSetName) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileSetName) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileSetName.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileSetName proto.InternalMessageInfo

type RpcBlockFileSetNameRequest 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 *RpcBlockFileSetNameRequest) Reset()         { *m = RpcBlockFileSetNameRequest{} }
func (m *RpcBlockFileSetNameRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileSetNameRequest) ProtoMessage()    {}
func (*RpcBlockFileSetNameRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 0}
}
func (m *RpcBlockFileSetNameRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileSetNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileSetNameRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileSetNameRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileSetNameRequest.Merge(m, src)
}
func (m *RpcBlockFileSetNameRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileSetNameRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileSetNameRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileSetNameRequest proto.InternalMessageInfo

func (m *RpcBlockFileSetNameRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockFileSetNameRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockFileSetNameRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type RpcBlockFileSetNameResponse struct {
	Error *RpcBlockFileSetNameResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                    `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockFileSetNameResponse) Reset()         { *m = RpcBlockFileSetNameResponse{} }
func (m *RpcBlockFileSetNameResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileSetNameResponse) ProtoMessage()    {}
func (*RpcBlockFileSetNameResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 1}
}
func (m *RpcBlockFileSetNameResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileSetNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileSetNameResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileSetNameResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileSetNameResponse.Merge(m, src)
}
func (m *RpcBlockFileSetNameResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileSetNameResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileSetNameResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileSetNameResponse proto.InternalMessageInfo

func (m *RpcBlockFileSetNameResponse) GetError() *RpcBlockFileSetNameResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockFileSetNameResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockFileSetNameResponseError struct {
	Code        RpcBlockFileSetNameResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockFileSetNameResponseErrorCode" json:"code,omitempty"`
	Description string                               `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockFileSetNameResponseError) Reset()         { *m = RpcBlockFileSetNameResponseError{} }
func (m *RpcBlockFileSetNameResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileSetNameResponseError) ProtoMessage()    {}
func (*RpcBlockFileSetNameResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 0, 1, 0}
}
func (m *RpcBlockFileSetNameResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileSetNameResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileSetNameResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileSetNameResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileSetNameResponseError.Merge(m, src)
}
func (m *RpcBlockFileSetNameResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileSetNameResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileSetNameResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileSetNameResponseError proto.InternalMessageInfo

func (m *RpcBlockFileSetNameResponseError) GetCode() RpcBlockFileSetNameResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockFileSetNameResponseError_NULL
}

func (m *RpcBlockFileSetNameResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

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, 18, 1}
}
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, 18, 1, 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, 18, 1, 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, 18, 1, 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 RpcBlockFileListSetStyle struct {
}

func (m *RpcBlockFileListSetStyle) Reset()         { *m = RpcBlockFileListSetStyle{} }
func (m *RpcBlockFileListSetStyle) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileListSetStyle) ProtoMessage()    {}
func (*RpcBlockFileListSetStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 2}
}
func (m *RpcBlockFileListSetStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileListSetStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileListSetStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileListSetStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileListSetStyle.Merge(m, src)
}
func (m *RpcBlockFileListSetStyle) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileListSetStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileListSetStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileListSetStyle proto.InternalMessageInfo

type RpcBlockFileListSetStyleRequest 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 *RpcBlockFileListSetStyleRequest) Reset()         { *m = RpcBlockFileListSetStyleRequest{} }
func (m *RpcBlockFileListSetStyleRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileListSetStyleRequest) ProtoMessage()    {}
func (*RpcBlockFileListSetStyleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 2, 0}
}
func (m *RpcBlockFileListSetStyleRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileListSetStyleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileListSetStyleRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileListSetStyleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileListSetStyleRequest.Merge(m, src)
}
func (m *RpcBlockFileListSetStyleRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileListSetStyleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileListSetStyleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileListSetStyleRequest proto.InternalMessageInfo

func (m *RpcBlockFileListSetStyleRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockFileListSetStyleRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

func (m *RpcBlockFileListSetStyleRequest) GetStyle() model.BlockContentFileStyle {
	if m != nil {
		return m.Style
	}
	return model.BlockContentFile_Auto
}

type RpcBlockFileListSetStyleResponse struct {
	Error *RpcBlockFileListSetStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                         `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockFileListSetStyleResponse) Reset()         { *m = RpcBlockFileListSetStyleResponse{} }
func (m *RpcBlockFileListSetStyleResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileListSetStyleResponse) ProtoMessage()    {}
func (*RpcBlockFileListSetStyleResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 2, 1}
}
func (m *RpcBlockFileListSetStyleResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileListSetStyleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileListSetStyleResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileListSetStyleResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileListSetStyleResponse.Merge(m, src)
}
func (m *RpcBlockFileListSetStyleResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileListSetStyleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileListSetStyleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileListSetStyleResponse proto.InternalMessageInfo

func (m *RpcBlockFileListSetStyleResponse) GetError() *RpcBlockFileListSetStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockFileListSetStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockFileListSetStyleResponseError struct {
	Code        RpcBlockFileListSetStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockFileListSetStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockFileListSetStyleResponseError) Reset()         { *m = RpcBlockFileListSetStyleResponseError{} }
func (m *RpcBlockFileListSetStyleResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockFileListSetStyleResponseError) ProtoMessage()    {}
func (*RpcBlockFileListSetStyleResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 18, 2, 1, 0}
}
func (m *RpcBlockFileListSetStyleResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockFileListSetStyleResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockFileListSetStyleResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockFileListSetStyleResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockFileListSetStyleResponseError.Merge(m, src)
}
func (m *RpcBlockFileListSetStyleResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockFileListSetStyleResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockFileListSetStyleResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockFileListSetStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockFileListSetStyleResponseError) GetCode() RpcBlockFileListSetStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockFileListSetStyleResponseError_NULL
}

func (m *RpcBlockFileListSetStyleResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockImage struct {
}

func (m *RpcBlockImage) Reset()         { *m = RpcBlockImage{} }
func (m *RpcBlockImage) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImage) ProtoMessage()    {}
func (*RpcBlockImage) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19}
}
func (m *RpcBlockImage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImage.Merge(m, src)
}
func (m *RpcBlockImage) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImage) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImage.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImage proto.InternalMessageInfo

type RpcBlockImageSetName struct {
}

func (m *RpcBlockImageSetName) Reset()         { *m = RpcBlockImageSetName{} }
func (m *RpcBlockImageSetName) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetName) ProtoMessage()    {}
func (*RpcBlockImageSetName) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0}
}
func (m *RpcBlockImageSetName) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetName) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetName.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetName) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetName.Merge(m, src)
}
func (m *RpcBlockImageSetName) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetName) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetName.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetName proto.InternalMessageInfo

type RpcBlockImageSetNameRequest 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 *RpcBlockImageSetNameRequest) Reset()         { *m = RpcBlockImageSetNameRequest{} }
func (m *RpcBlockImageSetNameRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetNameRequest) ProtoMessage()    {}
func (*RpcBlockImageSetNameRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 0}
}
func (m *RpcBlockImageSetNameRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetNameRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetNameRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetNameRequest.Merge(m, src)
}
func (m *RpcBlockImageSetNameRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetNameRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetNameRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetNameRequest proto.InternalMessageInfo

func (m *RpcBlockImageSetNameRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockImageSetNameRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockImageSetNameRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type RpcBlockImageSetNameResponse struct {
	Error *RpcBlockImageSetNameResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcBlockImageSetNameResponse) Reset()         { *m = RpcBlockImageSetNameResponse{} }
func (m *RpcBlockImageSetNameResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetNameResponse) ProtoMessage()    {}
func (*RpcBlockImageSetNameResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 1}
}
func (m *RpcBlockImageSetNameResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetNameResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetNameResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetNameResponse.Merge(m, src)
}
func (m *RpcBlockImageSetNameResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetNameResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetNameResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetNameResponse proto.InternalMessageInfo

func (m *RpcBlockImageSetNameResponse) GetError() *RpcBlockImageSetNameResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockImageSetNameResponseError struct {
	Code        RpcBlockImageSetNameResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockImageSetNameResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockImageSetNameResponseError) Reset()         { *m = RpcBlockImageSetNameResponseError{} }
func (m *RpcBlockImageSetNameResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetNameResponseError) ProtoMessage()    {}
func (*RpcBlockImageSetNameResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 0, 1, 0}
}
func (m *RpcBlockImageSetNameResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetNameResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetNameResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetNameResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetNameResponseError.Merge(m, src)
}
func (m *RpcBlockImageSetNameResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetNameResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetNameResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetNameResponseError proto.InternalMessageInfo

func (m *RpcBlockImageSetNameResponseError) GetCode() RpcBlockImageSetNameResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockImageSetNameResponseError_NULL
}

func (m *RpcBlockImageSetNameResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockImageSetWidth struct {
}

func (m *RpcBlockImageSetWidth) Reset()         { *m = RpcBlockImageSetWidth{} }
func (m *RpcBlockImageSetWidth) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetWidth) ProtoMessage()    {}
func (*RpcBlockImageSetWidth) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1}
}
func (m *RpcBlockImageSetWidth) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetWidth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetWidth.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetWidth) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetWidth.Merge(m, src)
}
func (m *RpcBlockImageSetWidth) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetWidth) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetWidth.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetWidth proto.InternalMessageInfo

type RpcBlockImageSetWidthRequest 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 *RpcBlockImageSetWidthRequest) Reset()         { *m = RpcBlockImageSetWidthRequest{} }
func (m *RpcBlockImageSetWidthRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetWidthRequest) ProtoMessage()    {}
func (*RpcBlockImageSetWidthRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 0}
}
func (m *RpcBlockImageSetWidthRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetWidthRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetWidthRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetWidthRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetWidthRequest.Merge(m, src)
}
func (m *RpcBlockImageSetWidthRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetWidthRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetWidthRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetWidthRequest proto.InternalMessageInfo

func (m *RpcBlockImageSetWidthRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockImageSetWidthRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockImageSetWidthRequest) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

type RpcBlockImageSetWidthResponse struct {
	Error *RpcBlockImageSetWidthResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcBlockImageSetWidthResponse) Reset()         { *m = RpcBlockImageSetWidthResponse{} }
func (m *RpcBlockImageSetWidthResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetWidthResponse) ProtoMessage()    {}
func (*RpcBlockImageSetWidthResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 1}
}
func (m *RpcBlockImageSetWidthResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetWidthResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetWidthResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetWidthResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetWidthResponse.Merge(m, src)
}
func (m *RpcBlockImageSetWidthResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetWidthResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetWidthResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetWidthResponse proto.InternalMessageInfo

func (m *RpcBlockImageSetWidthResponse) GetError() *RpcBlockImageSetWidthResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockImageSetWidthResponseError struct {
	Code        RpcBlockImageSetWidthResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockImageSetWidthResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockImageSetWidthResponseError) Reset()         { *m = RpcBlockImageSetWidthResponseError{} }
func (m *RpcBlockImageSetWidthResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockImageSetWidthResponseError) ProtoMessage()    {}
func (*RpcBlockImageSetWidthResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 19, 1, 1, 0}
}
func (m *RpcBlockImageSetWidthResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockImageSetWidthResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockImageSetWidthResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockImageSetWidthResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockImageSetWidthResponseError.Merge(m, src)
}
func (m *RpcBlockImageSetWidthResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockImageSetWidthResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockImageSetWidthResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockImageSetWidthResponseError proto.InternalMessageInfo

func (m *RpcBlockImageSetWidthResponseError) GetCode() RpcBlockImageSetWidthResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockImageSetWidthResponseError_NULL
}

func (m *RpcBlockImageSetWidthResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockVideo struct {
}

func (m *RpcBlockVideo) Reset()         { *m = RpcBlockVideo{} }
func (m *RpcBlockVideo) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideo) ProtoMessage()    {}
func (*RpcBlockVideo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20}
}
func (m *RpcBlockVideo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideo.Merge(m, src)
}
func (m *RpcBlockVideo) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideo) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideo.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideo proto.InternalMessageInfo

type RpcBlockVideoSetName struct {
}

func (m *RpcBlockVideoSetName) Reset()         { *m = RpcBlockVideoSetName{} }
func (m *RpcBlockVideoSetName) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetName) ProtoMessage()    {}
func (*RpcBlockVideoSetName) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0}
}
func (m *RpcBlockVideoSetName) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetName) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetName.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetName) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetName.Merge(m, src)
}
func (m *RpcBlockVideoSetName) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetName) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetName.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetName proto.InternalMessageInfo

type RpcBlockVideoSetNameRequest 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 *RpcBlockVideoSetNameRequest) Reset()         { *m = RpcBlockVideoSetNameRequest{} }
func (m *RpcBlockVideoSetNameRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetNameRequest) ProtoMessage()    {}
func (*RpcBlockVideoSetNameRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 0}
}
func (m *RpcBlockVideoSetNameRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetNameRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetNameRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetNameRequest.Merge(m, src)
}
func (m *RpcBlockVideoSetNameRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetNameRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetNameRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetNameRequest proto.InternalMessageInfo

func (m *RpcBlockVideoSetNameRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockVideoSetNameRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockVideoSetNameRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type RpcBlockVideoSetNameResponse struct {
	Error *RpcBlockVideoSetNameResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcBlockVideoSetNameResponse) Reset()         { *m = RpcBlockVideoSetNameResponse{} }
func (m *RpcBlockVideoSetNameResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetNameResponse) ProtoMessage()    {}
func (*RpcBlockVideoSetNameResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 1}
}
func (m *RpcBlockVideoSetNameResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetNameResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetNameResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetNameResponse.Merge(m, src)
}
func (m *RpcBlockVideoSetNameResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetNameResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetNameResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetNameResponse proto.InternalMessageInfo

func (m *RpcBlockVideoSetNameResponse) GetError() *RpcBlockVideoSetNameResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockVideoSetNameResponseError struct {
	Code        RpcBlockVideoSetNameResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockVideoSetNameResponseErrorCode" json:"code,omitempty"`
	Description string                                `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockVideoSetNameResponseError) Reset()         { *m = RpcBlockVideoSetNameResponseError{} }
func (m *RpcBlockVideoSetNameResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetNameResponseError) ProtoMessage()    {}
func (*RpcBlockVideoSetNameResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 0, 1, 0}
}
func (m *RpcBlockVideoSetNameResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetNameResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetNameResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetNameResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetNameResponseError.Merge(m, src)
}
func (m *RpcBlockVideoSetNameResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetNameResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetNameResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetNameResponseError proto.InternalMessageInfo

func (m *RpcBlockVideoSetNameResponseError) GetCode() RpcBlockVideoSetNameResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockVideoSetNameResponseError_NULL
}

func (m *RpcBlockVideoSetNameResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockVideoSetWidth struct {
}

func (m *RpcBlockVideoSetWidth) Reset()         { *m = RpcBlockVideoSetWidth{} }
func (m *RpcBlockVideoSetWidth) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetWidth) ProtoMessage()    {}
func (*RpcBlockVideoSetWidth) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 1}
}
func (m *RpcBlockVideoSetWidth) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetWidth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetWidth.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetWidth) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetWidth.Merge(m, src)
}
func (m *RpcBlockVideoSetWidth) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetWidth) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetWidth.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetWidth proto.InternalMessageInfo

type RpcBlockVideoSetWidthRequest 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 *RpcBlockVideoSetWidthRequest) Reset()         { *m = RpcBlockVideoSetWidthRequest{} }
func (m *RpcBlockVideoSetWidthRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetWidthRequest) ProtoMessage()    {}
func (*RpcBlockVideoSetWidthRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 1, 0}
}
func (m *RpcBlockVideoSetWidthRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetWidthRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetWidthRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetWidthRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetWidthRequest.Merge(m, src)
}
func (m *RpcBlockVideoSetWidthRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetWidthRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetWidthRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetWidthRequest proto.InternalMessageInfo

func (m *RpcBlockVideoSetWidthRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockVideoSetWidthRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockVideoSetWidthRequest) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

type RpcBlockVideoSetWidthResponse struct {
	Error *RpcBlockVideoSetWidthResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

func (m *RpcBlockVideoSetWidthResponse) Reset()         { *m = RpcBlockVideoSetWidthResponse{} }
func (m *RpcBlockVideoSetWidthResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetWidthResponse) ProtoMessage()    {}
func (*RpcBlockVideoSetWidthResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 1, 1}
}
func (m *RpcBlockVideoSetWidthResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetWidthResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetWidthResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetWidthResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetWidthResponse.Merge(m, src)
}
func (m *RpcBlockVideoSetWidthResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetWidthResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetWidthResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetWidthResponse proto.InternalMessageInfo

func (m *RpcBlockVideoSetWidthResponse) GetError() *RpcBlockVideoSetWidthResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

type RpcBlockVideoSetWidthResponseError struct {
	Code        RpcBlockVideoSetWidthResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockVideoSetWidthResponseErrorCode" json:"code,omitempty"`
	Description string                                 `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockVideoSetWidthResponseError) Reset()         { *m = RpcBlockVideoSetWidthResponseError{} }
func (m *RpcBlockVideoSetWidthResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockVideoSetWidthResponseError) ProtoMessage()    {}
func (*RpcBlockVideoSetWidthResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 20, 1, 1, 0}
}
func (m *RpcBlockVideoSetWidthResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockVideoSetWidthResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockVideoSetWidthResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockVideoSetWidthResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockVideoSetWidthResponseError.Merge(m, src)
}
func (m *RpcBlockVideoSetWidthResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockVideoSetWidthResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockVideoSetWidthResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockVideoSetWidthResponseError proto.InternalMessageInfo

func (m *RpcBlockVideoSetWidthResponseError) GetCode() RpcBlockVideoSetWidthResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockVideoSetWidthResponseError_NULL
}

func (m *RpcBlockVideoSetWidthResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockLink struct {
}

func (m *RpcBlockLink) Reset()         { *m = RpcBlockLink{} }
func (m *RpcBlockLink) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLink) ProtoMessage()    {}
func (*RpcBlockLink) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21}
}
func (m *RpcBlockLink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLink.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLink.Merge(m, src)
}
func (m *RpcBlockLink) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLink) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLink.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLink proto.InternalMessageInfo

type RpcBlockLinkCreateWithObject struct {
}

func (m *RpcBlockLinkCreateWithObject) Reset()         { *m = RpcBlockLinkCreateWithObject{} }
func (m *RpcBlockLinkCreateWithObject) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLinkCreateWithObject) ProtoMessage()    {}
func (*RpcBlockLinkCreateWithObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0}
}
func (m *RpcBlockLinkCreateWithObject) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkCreateWithObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkCreateWithObject.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkCreateWithObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkCreateWithObject.Merge(m, src)
}
func (m *RpcBlockLinkCreateWithObject) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkCreateWithObject) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkCreateWithObject.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkCreateWithObject proto.InternalMessageInfo

type RpcBlockLinkCreateWithObjectRequest 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"`
	InternalFlags []*model.InternalFlag `protobuf:"bytes,7,rep,name=internalFlags,proto3" json:"internalFlags,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 *RpcBlockLinkCreateWithObjectRequest) Reset()         { *m = RpcBlockLinkCreateWithObjectRequest{} }
func (m *RpcBlockLinkCreateWithObjectRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLinkCreateWithObjectRequest) ProtoMessage()    {}
func (*RpcBlockLinkCreateWithObjectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 0}
}
func (m *RpcBlockLinkCreateWithObjectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkCreateWithObjectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkCreateWithObjectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkCreateWithObjectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkCreateWithObjectRequest.Merge(m, src)
}
func (m *RpcBlockLinkCreateWithObjectRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkCreateWithObjectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkCreateWithObjectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkCreateWithObjectRequest proto.InternalMessageInfo

func (m *RpcBlockLinkCreateWithObjectRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockLinkCreateWithObjectRequest) GetDetails() *types.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *RpcBlockLinkCreateWithObjectRequest) GetTemplateId() string {
	if m != nil {
		return m.TemplateId
	}
	return ""
}

func (m *RpcBlockLinkCreateWithObjectRequest) GetInternalFlags() []*model.InternalFlag {
	if m != nil {
		return m.InternalFlags
	}
	return nil
}

func (m *RpcBlockLinkCreateWithObjectRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockLinkCreateWithObjectRequest) GetPosition() model.BlockPosition {
	if m != nil {
		return m.Position
	}
	return model.Block_None
}

func (m *RpcBlockLinkCreateWithObjectRequest) GetFields() *types.Struct {
	if m != nil {
		return m.Fields
	}
	return nil
}

type RpcBlockLinkCreateWithObjectResponse struct {
	Error    *RpcBlockLinkCreateWithObjectResponseError `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 *RpcBlockLinkCreateWithObjectResponse) Reset()         { *m = RpcBlockLinkCreateWithObjectResponse{} }
func (m *RpcBlockLinkCreateWithObjectResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLinkCreateWithObjectResponse) ProtoMessage()    {}
func (*RpcBlockLinkCreateWithObjectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 1}
}
func (m *RpcBlockLinkCreateWithObjectResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkCreateWithObjectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkCreateWithObjectResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkCreateWithObjectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkCreateWithObjectResponse.Merge(m, src)
}
func (m *RpcBlockLinkCreateWithObjectResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkCreateWithObjectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkCreateWithObjectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkCreateWithObjectResponse proto.InternalMessageInfo

func (m *RpcBlockLinkCreateWithObjectResponse) GetError() *RpcBlockLinkCreateWithObjectResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockLinkCreateWithObjectResponse) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockLinkCreateWithObjectResponse) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockLinkCreateWithObjectResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockLinkCreateWithObjectResponseError struct {
	Code        RpcBlockLinkCreateWithObjectResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockLinkCreateWithObjectResponseErrorCode" json:"code,omitempty"`
	Description string                                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockLinkCreateWithObjectResponseError) Reset() {
	*m = RpcBlockLinkCreateWithObjectResponseError{}
}
func (m *RpcBlockLinkCreateWithObjectResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockLinkCreateWithObjectResponseError) ProtoMessage() {}
func (*RpcBlockLinkCreateWithObjectResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 0, 1, 0}
}
func (m *RpcBlockLinkCreateWithObjectResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkCreateWithObjectResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkCreateWithObjectResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkCreateWithObjectResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkCreateWithObjectResponseError.Merge(m, src)
}
func (m *RpcBlockLinkCreateWithObjectResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkCreateWithObjectResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkCreateWithObjectResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkCreateWithObjectResponseError proto.InternalMessageInfo

func (m *RpcBlockLinkCreateWithObjectResponseError) GetCode() RpcBlockLinkCreateWithObjectResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockLinkCreateWithObjectResponseError_NULL
}

func (m *RpcBlockLinkCreateWithObjectResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockLinkListSetAppearance struct {
}

func (m *RpcBlockLinkListSetAppearance) Reset()         { *m = RpcBlockLinkListSetAppearance{} }
func (m *RpcBlockLinkListSetAppearance) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLinkListSetAppearance) ProtoMessage()    {}
func (*RpcBlockLinkListSetAppearance) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 1}
}
func (m *RpcBlockLinkListSetAppearance) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkListSetAppearance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkListSetAppearance.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkListSetAppearance) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkListSetAppearance.Merge(m, src)
}
func (m *RpcBlockLinkListSetAppearance) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkListSetAppearance) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkListSetAppearance.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkListSetAppearance proto.InternalMessageInfo

type RpcBlockLinkListSetAppearanceRequest 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"`
	IconSize    model.BlockContentLinkIconSize    `protobuf:"varint,4,opt,name=iconSize,proto3,enum=anytype.model.BlockContentLinkIconSize" json:"iconSize,omitempty"`
	CardStyle   model.BlockContentLinkCardStyle   `protobuf:"varint,5,opt,name=cardStyle,proto3,enum=anytype.model.BlockContentLinkCardStyle" json:"cardStyle,omitempty"`
	Description model.BlockContentLinkDescription `protobuf:"varint,6,opt,name=description,proto3,enum=anytype.model.BlockContentLinkDescription" json:"description,omitempty"`
	Relations   []string                          `protobuf:"bytes,7,rep,name=relations,proto3" json:"relations,omitempty"`
}

func (m *RpcBlockLinkListSetAppearanceRequest) Reset()         { *m = RpcBlockLinkListSetAppearanceRequest{} }
func (m *RpcBlockLinkListSetAppearanceRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLinkListSetAppearanceRequest) ProtoMessage()    {}
func (*RpcBlockLinkListSetAppearanceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 1, 0}
}
func (m *RpcBlockLinkListSetAppearanceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkListSetAppearanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkListSetAppearanceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkListSetAppearanceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkListSetAppearanceRequest.Merge(m, src)
}
func (m *RpcBlockLinkListSetAppearanceRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkListSetAppearanceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkListSetAppearanceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkListSetAppearanceRequest proto.InternalMessageInfo

func (m *RpcBlockLinkListSetAppearanceRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockLinkListSetAppearanceRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

func (m *RpcBlockLinkListSetAppearanceRequest) GetIconSize() model.BlockContentLinkIconSize {
	if m != nil {
		return m.IconSize
	}
	return model.BlockContentLink_SizeNone
}

func (m *RpcBlockLinkListSetAppearanceRequest) GetCardStyle() model.BlockContentLinkCardStyle {
	if m != nil {
		return m.CardStyle
	}
	return model.BlockContentLink_Text
}

func (m *RpcBlockLinkListSetAppearanceRequest) GetDescription() model.BlockContentLinkDescription {
	if m != nil {
		return m.Description
	}
	return model.BlockContentLink_None
}

func (m *RpcBlockLinkListSetAppearanceRequest) GetRelations() []string {
	if m != nil {
		return m.Relations
	}
	return nil
}

type RpcBlockLinkListSetAppearanceResponse struct {
	Error *RpcBlockLinkListSetAppearanceResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                              `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockLinkListSetAppearanceResponse) Reset()         { *m = RpcBlockLinkListSetAppearanceResponse{} }
func (m *RpcBlockLinkListSetAppearanceResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockLinkListSetAppearanceResponse) ProtoMessage()    {}
func (*RpcBlockLinkListSetAppearanceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 1, 1}
}
func (m *RpcBlockLinkListSetAppearanceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkListSetAppearanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkListSetAppearanceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkListSetAppearanceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkListSetAppearanceResponse.Merge(m, src)
}
func (m *RpcBlockLinkListSetAppearanceResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkListSetAppearanceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkListSetAppearanceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkListSetAppearanceResponse proto.InternalMessageInfo

func (m *RpcBlockLinkListSetAppearanceResponse) GetError() *RpcBlockLinkListSetAppearanceResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockLinkListSetAppearanceResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockLinkListSetAppearanceResponseError struct {
	Code        RpcBlockLinkListSetAppearanceResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockLinkListSetAppearanceResponseErrorCode" json:"code,omitempty"`
	Description string                                         `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockLinkListSetAppearanceResponseError) Reset() {
	*m = RpcBlockLinkListSetAppearanceResponseError{}
}
func (m *RpcBlockLinkListSetAppearanceResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockLinkListSetAppearanceResponseError) ProtoMessage() {}
func (*RpcBlockLinkListSetAppearanceResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 21, 1, 1, 0}
}
func (m *RpcBlockLinkListSetAppearanceResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockLinkListSetAppearanceResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockLinkListSetAppearanceResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockLinkListSetAppearanceResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockLinkListSetAppearanceResponseError.Merge(m, src)
}
func (m *RpcBlockLinkListSetAppearanceResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockLinkListSetAppearanceResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockLinkListSetAppearanceResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockLinkListSetAppearanceResponseError proto.InternalMessageInfo

func (m *RpcBlockLinkListSetAppearanceResponseError) GetCode() RpcBlockLinkListSetAppearanceResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockLinkListSetAppearanceResponseError_NULL
}

func (m *RpcBlockLinkListSetAppearanceResponseError) 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, 22}
}
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, 22, 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, 22, 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, 22, 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, 22, 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, 22, 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"`
	RelationKey string `protobuf:"bytes,3,opt,name=relationKey,proto3" json:"relationKey,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, 22, 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) GetRelationKey() string {
	if m != nil {
		return m.RelationKey
	}
	return ""
}

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, 22, 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, 22, 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 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, 23}
}
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, 23, 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, 23, 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, 23, 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, 23, 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, 23, 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, 23, 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, 23, 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, 23, 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 RpcBlockDiv struct {
}

func (m *RpcBlockDiv) Reset()         { *m = RpcBlockDiv{} }
func (m *RpcBlockDiv) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDiv) ProtoMessage()    {}
func (*RpcBlockDiv) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24}
}
func (m *RpcBlockDiv) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDiv) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDiv.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDiv) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDiv.Merge(m, src)
}
func (m *RpcBlockDiv) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDiv) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDiv.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDiv proto.InternalMessageInfo

type RpcBlockDivListSetStyle struct {
}

func (m *RpcBlockDivListSetStyle) Reset()         { *m = RpcBlockDivListSetStyle{} }
func (m *RpcBlockDivListSetStyle) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDivListSetStyle) ProtoMessage()    {}
func (*RpcBlockDivListSetStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0}
}
func (m *RpcBlockDivListSetStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDivListSetStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDivListSetStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDivListSetStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDivListSetStyle.Merge(m, src)
}
func (m *RpcBlockDivListSetStyle) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDivListSetStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDivListSetStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDivListSetStyle proto.InternalMessageInfo

type RpcBlockDivListSetStyleRequest 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 *RpcBlockDivListSetStyleRequest) Reset()         { *m = RpcBlockDivListSetStyleRequest{} }
func (m *RpcBlockDivListSetStyleRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDivListSetStyleRequest) ProtoMessage()    {}
func (*RpcBlockDivListSetStyleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 0}
}
func (m *RpcBlockDivListSetStyleRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDivListSetStyleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDivListSetStyleRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDivListSetStyleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDivListSetStyleRequest.Merge(m, src)
}
func (m *RpcBlockDivListSetStyleRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDivListSetStyleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDivListSetStyleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDivListSetStyleRequest proto.InternalMessageInfo

func (m *RpcBlockDivListSetStyleRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDivListSetStyleRequest) GetBlockIds() []string {
	if m != nil {
		return m.BlockIds
	}
	return nil
}

func (m *RpcBlockDivListSetStyleRequest) GetStyle() model.BlockContentDivStyle {
	if m != nil {
		return m.Style
	}
	return model.BlockContentDiv_Line
}

type RpcBlockDivListSetStyleResponse struct {
	Error *RpcBlockDivListSetStyleResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                        `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockDivListSetStyleResponse) Reset()         { *m = RpcBlockDivListSetStyleResponse{} }
func (m *RpcBlockDivListSetStyleResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDivListSetStyleResponse) ProtoMessage()    {}
func (*RpcBlockDivListSetStyleResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 1}
}
func (m *RpcBlockDivListSetStyleResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDivListSetStyleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDivListSetStyleResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDivListSetStyleResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDivListSetStyleResponse.Merge(m, src)
}
func (m *RpcBlockDivListSetStyleResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDivListSetStyleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDivListSetStyleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDivListSetStyleResponse proto.InternalMessageInfo

func (m *RpcBlockDivListSetStyleResponse) GetError() *RpcBlockDivListSetStyleResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDivListSetStyleResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDivListSetStyleResponseError struct {
	Code        RpcBlockDivListSetStyleResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDivListSetStyleResponseErrorCode" json:"code,omitempty"`
	Description string                                   `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDivListSetStyleResponseError) Reset()         { *m = RpcBlockDivListSetStyleResponseError{} }
func (m *RpcBlockDivListSetStyleResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDivListSetStyleResponseError) ProtoMessage()    {}
func (*RpcBlockDivListSetStyleResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 24, 0, 1, 0}
}
func (m *RpcBlockDivListSetStyleResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDivListSetStyleResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDivListSetStyleResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDivListSetStyleResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDivListSetStyleResponseError.Merge(m, src)
}
func (m *RpcBlockDivListSetStyleResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDivListSetStyleResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDivListSetStyleResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDivListSetStyleResponseError proto.InternalMessageInfo

func (m *RpcBlockDivListSetStyleResponseError) GetCode() RpcBlockDivListSetStyleResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDivListSetStyleResponseError_NULL
}

func (m *RpcBlockDivListSetStyleResponseError) 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, 25}
}
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 RpcBlockDataviewView struct {
}

func (m *RpcBlockDataviewView) Reset()         { *m = RpcBlockDataviewView{} }
func (m *RpcBlockDataviewView) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewView) ProtoMessage()    {}
func (*RpcBlockDataviewView) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 0}
}
func (m *RpcBlockDataviewView) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewView.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewView) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewView.Merge(m, src)
}
func (m *RpcBlockDataviewView) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewView) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewView.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewView 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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, 25, 0, 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 RpcBlockDataviewRelation struct {
}

func (m *RpcBlockDataviewRelation) Reset()         { *m = RpcBlockDataviewRelation{} }
func (m *RpcBlockDataviewRelation) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewRelation) ProtoMessage()    {}
func (*RpcBlockDataviewRelation) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 1}
}
func (m *RpcBlockDataviewRelation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewRelation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewRelation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewRelation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewRelation.Merge(m, src)
}
func (m *RpcBlockDataviewRelation) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewRelation) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewRelation.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewRelation proto.InternalMessageInfo

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, 25, 1, 0}
}
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"`
	RelationKeys []string `protobuf:"bytes,3,rep,name=relationKeys,proto3" json:"relationKeys,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, 25, 1, 0, 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) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	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"`
}

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, 25, 1, 0, 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
}

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, 25, 1, 0, 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 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, 25, 1, 1}
}
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"`
	RelationKeys []string `protobuf:"bytes,3,rep,name=relationKeys,proto3" json:"relationKeys,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, 25, 1, 1, 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) GetRelationKeys() []string {
	if m != nil {
		return m.RelationKeys
	}
	return nil
}

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, 25, 1, 1, 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, 25, 1, 1, 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 ""
}

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, 25, 1, 2}
}
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, 25, 1, 2, 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, 25, 1, 2, 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, 25, 1, 2, 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, 25, 2}
}
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, 25, 2, 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, 25, 2, 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, 25, 2, 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 RpcBlockDataviewGroupOrder struct {
}

func (m *RpcBlockDataviewGroupOrder) Reset()         { *m = RpcBlockDataviewGroupOrder{} }
func (m *RpcBlockDataviewGroupOrder) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewGroupOrder) ProtoMessage()    {}
func (*RpcBlockDataviewGroupOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 3}
}
func (m *RpcBlockDataviewGroupOrder) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewGroupOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewGroupOrder.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewGroupOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewGroupOrder.Merge(m, src)
}
func (m *RpcBlockDataviewGroupOrder) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewGroupOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewGroupOrder.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewGroupOrder proto.InternalMessageInfo

type RpcBlockDataviewGroupOrderUpdate struct {
}

func (m *RpcBlockDataviewGroupOrderUpdate) Reset()         { *m = RpcBlockDataviewGroupOrderUpdate{} }
func (m *RpcBlockDataviewGroupOrderUpdate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewGroupOrderUpdate) ProtoMessage()    {}
func (*RpcBlockDataviewGroupOrderUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 3, 0}
}
func (m *RpcBlockDataviewGroupOrderUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewGroupOrderUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewGroupOrderUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewGroupOrderUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdate.Merge(m, src)
}
func (m *RpcBlockDataviewGroupOrderUpdate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewGroupOrderUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewGroupOrderUpdate proto.InternalMessageInfo

type RpcBlockDataviewGroupOrderUpdateRequest 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"`
	GroupOrder *model.BlockContentDataviewGroupOrder `protobuf:"bytes,3,opt,name=groupOrder,proto3" json:"groupOrder,omitempty"`
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) Reset() {
	*m = RpcBlockDataviewGroupOrderUpdateRequest{}
}
func (m *RpcBlockDataviewGroupOrderUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewGroupOrderUpdateRequest) ProtoMessage()    {}
func (*RpcBlockDataviewGroupOrderUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 3, 0, 0}
}
func (m *RpcBlockDataviewGroupOrderUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewGroupOrderUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewGroupOrderUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateRequest.Merge(m, src)
}
func (m *RpcBlockDataviewGroupOrderUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewGroupOrderUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateRequest proto.InternalMessageInfo

func (m *RpcBlockDataviewGroupOrderUpdateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) GetGroupOrder() *model.BlockContentDataviewGroupOrder {
	if m != nil {
		return m.GroupOrder
	}
	return nil
}

type RpcBlockDataviewGroupOrderUpdateResponse struct {
	Error *RpcBlockDataviewGroupOrderUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                 `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockDataviewGroupOrderUpdateResponse) Reset() {
	*m = RpcBlockDataviewGroupOrderUpdateResponse{}
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewGroupOrderUpdateResponse) ProtoMessage()    {}
func (*RpcBlockDataviewGroupOrderUpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 3, 0, 1}
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponse.Merge(m, src)
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewGroupOrderUpdateResponse) GetError() *RpcBlockDataviewGroupOrderUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewGroupOrderUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewGroupOrderUpdateResponseError struct {
	Code        RpcBlockDataviewGroupOrderUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewGroupOrderUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                            `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDataviewGroupOrderUpdateResponseError) Reset() {
	*m = RpcBlockDataviewGroupOrderUpdateResponseError{}
}
func (m *RpcBlockDataviewGroupOrderUpdateResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewGroupOrderUpdateResponseError) ProtoMessage() {}
func (*RpcBlockDataviewGroupOrderUpdateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 3, 0, 1, 0}
}
func (m *RpcBlockDataviewGroupOrderUpdateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewGroupOrderUpdateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewGroupOrderUpdateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponseError.Merge(m, src)
}
func (m *RpcBlockDataviewGroupOrderUpdateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewGroupOrderUpdateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewGroupOrderUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewGroupOrderUpdateResponseError) GetCode() RpcBlockDataviewGroupOrderUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewGroupOrderUpdateResponseError_NULL
}

func (m *RpcBlockDataviewGroupOrderUpdateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockDataviewObjectOrder struct {
}

func (m *RpcBlockDataviewObjectOrder) Reset()         { *m = RpcBlockDataviewObjectOrder{} }
func (m *RpcBlockDataviewObjectOrder) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewObjectOrder) ProtoMessage()    {}
func (*RpcBlockDataviewObjectOrder) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 4}
}
func (m *RpcBlockDataviewObjectOrder) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewObjectOrder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewObjectOrder.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewObjectOrder) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewObjectOrder.Merge(m, src)
}
func (m *RpcBlockDataviewObjectOrder) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewObjectOrder) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewObjectOrder.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewObjectOrder proto.InternalMessageInfo

type RpcBlockDataviewObjectOrderUpdate struct {
}

func (m *RpcBlockDataviewObjectOrderUpdate) Reset()         { *m = RpcBlockDataviewObjectOrderUpdate{} }
func (m *RpcBlockDataviewObjectOrderUpdate) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewObjectOrderUpdate) ProtoMessage()    {}
func (*RpcBlockDataviewObjectOrderUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 4, 0}
}
func (m *RpcBlockDataviewObjectOrderUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewObjectOrderUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewObjectOrderUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewObjectOrderUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdate.Merge(m, src)
}
func (m *RpcBlockDataviewObjectOrderUpdate) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewObjectOrderUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewObjectOrderUpdate proto.InternalMessageInfo

type RpcBlockDataviewObjectOrderUpdateRequest 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"`
	ObjectOrders []*model.BlockContentDataviewObjectOrder `protobuf:"bytes,3,rep,name=objectOrders,proto3" json:"objectOrders,omitempty"`
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) Reset() {
	*m = RpcBlockDataviewObjectOrderUpdateRequest{}
}
func (m *RpcBlockDataviewObjectOrderUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewObjectOrderUpdateRequest) ProtoMessage()    {}
func (*RpcBlockDataviewObjectOrderUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 4, 0, 0}
}
func (m *RpcBlockDataviewObjectOrderUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewObjectOrderUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewObjectOrderUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateRequest.Merge(m, src)
}
func (m *RpcBlockDataviewObjectOrderUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewObjectOrderUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateRequest proto.InternalMessageInfo

func (m *RpcBlockDataviewObjectOrderUpdateRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) GetObjectOrders() []*model.BlockContentDataviewObjectOrder {
	if m != nil {
		return m.ObjectOrders
	}
	return nil
}

type RpcBlockDataviewObjectOrderUpdateResponse struct {
	Error *RpcBlockDataviewObjectOrderUpdateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Event *ResponseEvent                                  `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
}

func (m *RpcBlockDataviewObjectOrderUpdateResponse) Reset() {
	*m = RpcBlockDataviewObjectOrderUpdateResponse{}
}
func (m *RpcBlockDataviewObjectOrderUpdateResponse) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewObjectOrderUpdateResponse) ProtoMessage() {}
func (*RpcBlockDataviewObjectOrderUpdateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 4, 0, 1}
}
func (m *RpcBlockDataviewObjectOrderUpdateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewObjectOrderUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewObjectOrderUpdateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponse.Merge(m, src)
}
func (m *RpcBlockDataviewObjectOrderUpdateResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewObjectOrderUpdateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewObjectOrderUpdateResponse) GetError() *RpcBlockDataviewObjectOrderUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewObjectOrderUpdateResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcBlockDataviewObjectOrderUpdateResponseError struct {
	Code        RpcBlockDataviewObjectOrderUpdateResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewObjectOrderUpdateResponseErrorCode" json:"code,omitempty"`
	Description string                                             `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDataviewObjectOrderUpdateResponseError) Reset() {
	*m = RpcBlockDataviewObjectOrderUpdateResponseError{}
}
func (m *RpcBlockDataviewObjectOrderUpdateResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewObjectOrderUpdateResponseError) ProtoMessage() {}
func (*RpcBlockDataviewObjectOrderUpdateResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 4, 0, 1, 0}
}
func (m *RpcBlockDataviewObjectOrderUpdateResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewObjectOrderUpdateResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewObjectOrderUpdateResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponseError.Merge(m, src)
}
func (m *RpcBlockDataviewObjectOrderUpdateResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewObjectOrderUpdateResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewObjectOrderUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewObjectOrderUpdateResponseError) GetCode() RpcBlockDataviewObjectOrderUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewObjectOrderUpdateResponseError_NULL
}

func (m *RpcBlockDataviewObjectOrderUpdateResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcBlockDataviewCreateBookmark struct {
}

func (m *RpcBlockDataviewCreateBookmark) Reset()         { *m = RpcBlockDataviewCreateBookmark{} }
func (m *RpcBlockDataviewCreateBookmark) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewCreateBookmark) ProtoMessage()    {}
func (*RpcBlockDataviewCreateBookmark) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 5}
}
func (m *RpcBlockDataviewCreateBookmark) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewCreateBookmark) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewCreateBookmark.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewCreateBookmark) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewCreateBookmark.Merge(m, src)
}
func (m *RpcBlockDataviewCreateBookmark) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewCreateBookmark) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewCreateBookmark.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewCreateBookmark proto.InternalMessageInfo

type RpcBlockDataviewCreateBookmarkRequest 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 *RpcBlockDataviewCreateBookmarkRequest) Reset()         { *m = RpcBlockDataviewCreateBookmarkRequest{} }
func (m *RpcBlockDataviewCreateBookmarkRequest) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewCreateBookmarkRequest) ProtoMessage()    {}
func (*RpcBlockDataviewCreateBookmarkRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 5, 0}
}
func (m *RpcBlockDataviewCreateBookmarkRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewCreateBookmarkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewCreateBookmarkRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewCreateBookmarkRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewCreateBookmarkRequest.Merge(m, src)
}
func (m *RpcBlockDataviewCreateBookmarkRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewCreateBookmarkRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewCreateBookmarkRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewCreateBookmarkRequest proto.InternalMessageInfo

func (m *RpcBlockDataviewCreateBookmarkRequest) GetContextId() string {
	if m != nil {
		return m.ContextId
	}
	return ""
}

func (m *RpcBlockDataviewCreateBookmarkRequest) GetBlockId() string {
	if m != nil {
		return m.BlockId
	}
	return ""
}

func (m *RpcBlockDataviewCreateBookmarkRequest) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type RpcBlockDataviewCreateBookmarkResponse struct {
	Error *RpcBlockDataviewCreateBookmarkResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Id    string                                       `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RpcBlockDataviewCreateBookmarkResponse) Reset() {
	*m = RpcBlockDataviewCreateBookmarkResponse{}
}
func (m *RpcBlockDataviewCreateBookmarkResponse) String() string { return proto.CompactTextString(m) }
func (*RpcBlockDataviewCreateBookmarkResponse) ProtoMessage()    {}
func (*RpcBlockDataviewCreateBookmarkResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 5, 1}
}
func (m *RpcBlockDataviewCreateBookmarkResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewCreateBookmarkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewCreateBookmarkResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponse.Merge(m, src)
}
func (m *RpcBlockDataviewCreateBookmarkResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewCreateBookmarkResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponse proto.InternalMessageInfo

func (m *RpcBlockDataviewCreateBookmarkResponse) GetError() *RpcBlockDataviewCreateBookmarkResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcBlockDataviewCreateBookmarkResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type RpcBlockDataviewCreateBookmarkResponseError struct {
	Code        RpcBlockDataviewCreateBookmarkResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcBlockDataviewCreateBookmarkResponseErrorCode" json:"code,omitempty"`
	Description string                                          `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcBlockDataviewCreateBookmarkResponseError) Reset() {
	*m = RpcBlockDataviewCreateBookmarkResponseError{}
}
func (m *RpcBlockDataviewCreateBookmarkResponseError) String() string {
	return proto.CompactTextString(m)
}
func (*RpcBlockDataviewCreateBookmarkResponseError) ProtoMessage() {}
func (*RpcBlockDataviewCreateBookmarkResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 25, 5, 1, 0}
}
func (m *RpcBlockDataviewCreateBookmarkResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcBlockDataviewCreateBookmarkResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcBlockDataviewCreateBookmarkResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponseError.Merge(m, src)
}
func (m *RpcBlockDataviewCreateBookmarkResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcBlockDataviewCreateBookmarkResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcBlockDataviewCreateBookmarkResponseError proto.InternalMessageInfo

func (m *RpcBlockDataviewCreateBookmarkResponseError) GetCode() RpcBlockDataviewCreateBookmarkResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockDataviewCreateBookmarkResponseError_NULL
}

func (m *RpcBlockDataviewCreateBookmarkResponseError) 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, 26}
}
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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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, 26, 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 {
	ObjectId     string `protobuf:"bytes,1,opt,name=objectId,proto3" json:"objectId,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"`
	GenerateSvg  bool   `protobuf:"varint,4,opt,name=generateSvg,proto3" json:"generateSvg,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, 26, 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) GetObjectId() string {
	if m != nil {
		return m.ObjectId
	}
	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
}

func (m *RpcDebugTreeRequest) GetGenerateSvg() bool {
	if m != nil {
		return m.GenerateSvg
	}
	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, 26, 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, 26, 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 RpcDebugExportLocalstore struct {
}

func (m *RpcDebugExportLocalstore) Reset()         { *m = RpcDebugExportLocalstore{} }
func (m *RpcDebugExportLocalstore) String() string { return proto.CompactTextString(m) }
func (*RpcDebugExportLocalstore) ProtoMessage()    {}
func (*RpcDebugExportLocalstore) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 5}
}
func (m *RpcDebugExportLocalstore) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugExportLocalstore) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugExportLocalstore.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugExportLocalstore) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugExportLocalstore.Merge(m, src)
}
func (m *RpcDebugExportLocalstore) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugExportLocalstore) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugExportLocalstore.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugExportLocalstore proto.InternalMessageInfo

type RpcDebugExportLocalstoreRequest 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 *RpcDebugExportLocalstoreRequest) Reset()         { *m = RpcDebugExportLocalstoreRequest{} }
func (m *RpcDebugExportLocalstoreRequest) String() string { return proto.CompactTextString(m) }
func (*RpcDebugExportLocalstoreRequest) ProtoMessage()    {}
func (*RpcDebugExportLocalstoreRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 5, 0}
}
func (m *RpcDebugExportLocalstoreRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugExportLocalstoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugExportLocalstoreRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugExportLocalstoreRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugExportLocalstoreRequest.Merge(m, src)
}
func (m *RpcDebugExportLocalstoreRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugExportLocalstoreRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugExportLocalstoreRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugExportLocalstoreRequest proto.InternalMessageInfo

func (m *RpcDebugExportLocalstoreRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcDebugExportLocalstoreRequest) GetDocIds() []string {
	if m != nil {
		return m.DocIds
	}
	return nil
}

type RpcDebugExportLocalstoreResponse struct {
	Error *RpcDebugExportLocalstoreResponseError `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 *RpcDebugExportLocalstoreResponse) Reset()         { *m = RpcDebugExportLocalstoreResponse{} }
func (m *RpcDebugExportLocalstoreResponse) String() string { return proto.CompactTextString(m) }
func (*RpcDebugExportLocalstoreResponse) ProtoMessage()    {}
func (*RpcDebugExportLocalstoreResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 5, 1}
}
func (m *RpcDebugExportLocalstoreResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugExportLocalstoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugExportLocalstoreResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugExportLocalstoreResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugExportLocalstoreResponse.Merge(m, src)
}
func (m *RpcDebugExportLocalstoreResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugExportLocalstoreResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugExportLocalstoreResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugExportLocalstoreResponse proto.InternalMessageInfo

func (m *RpcDebugExportLocalstoreResponse) GetError() *RpcDebugExportLocalstoreResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcDebugExportLocalstoreResponse) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *RpcDebugExportLocalstoreResponse) GetEvent() *ResponseEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type RpcDebugExportLocalstoreResponseError struct {
	Code        RpcDebugExportLocalstoreResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcDebugExportLocalstoreResponseErrorCode" json:"code,omitempty"`
	Description string                                    `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcDebugExportLocalstoreResponseError) Reset()         { *m = RpcDebugExportLocalstoreResponseError{} }
func (m *RpcDebugExportLocalstoreResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcDebugExportLocalstoreResponseError) ProtoMessage()    {}
func (*RpcDebugExportLocalstoreResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 5, 1, 0}
}
func (m *RpcDebugExportLocalstoreResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugExportLocalstoreResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugExportLocalstoreResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugExportLocalstoreResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugExportLocalstoreResponseError.Merge(m, src)
}
func (m *RpcDebugExportLocalstoreResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugExportLocalstoreResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugExportLocalstoreResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugExportLocalstoreResponseError proto.InternalMessageInfo

func (m *RpcDebugExportLocalstoreResponseError) GetCode() RpcDebugExportLocalstoreResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcDebugExportLocalstoreResponseError_NULL
}

func (m *RpcDebugExportLocalstoreResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type RpcDebugPing struct {
}

func (m *RpcDebugPing) Reset()         { *m = RpcDebugPing{} }
func (m *RpcDebugPing) String() string { return proto.CompactTextString(m) }
func (*RpcDebugPing) ProtoMessage()    {}
func (*RpcDebugPing) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 6}
}
func (m *RpcDebugPing) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugPing.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugPing) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugPing.Merge(m, src)
}
func (m *RpcDebugPing) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugPing) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugPing.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugPing proto.InternalMessageInfo

type RpcDebugPingRequest 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 *RpcDebugPingRequest) Reset()         { *m = RpcDebugPingRequest{} }
func (m *RpcDebugPingRequest) String() string { return proto.CompactTextString(m) }
func (*RpcDebugPingRequest) ProtoMessage()    {}
func (*RpcDebugPingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 6, 0}
}
func (m *RpcDebugPingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugPingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugPingRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugPingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugPingRequest.Merge(m, src)
}
func (m *RpcDebugPingRequest) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugPingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugPingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugPingRequest proto.InternalMessageInfo

func (m *RpcDebugPingRequest) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *RpcDebugPingRequest) GetNumberOfEventsToSend() int32 {
	if m != nil {
		return m.NumberOfEventsToSend
	}
	return 0
}

type RpcDebugPingResponse struct {
	Error *RpcDebugPingResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Index int32                      `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *RpcDebugPingResponse) Reset()         { *m = RpcDebugPingResponse{} }
func (m *RpcDebugPingResponse) String() string { return proto.CompactTextString(m) }
func (*RpcDebugPingResponse) ProtoMessage()    {}
func (*RpcDebugPingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 6, 1}
}
func (m *RpcDebugPingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugPingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugPingResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugPingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugPingResponse.Merge(m, src)
}
func (m *RpcDebugPingResponse) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugPingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugPingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugPingResponse proto.InternalMessageInfo

func (m *RpcDebugPingResponse) GetError() *RpcDebugPingResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcDebugPingResponse) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

type RpcDebugPingResponseError struct {
	Code        RpcDebugPingResponseErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.RpcDebugPingResponseErrorCode" json:"code,omitempty"`
	Description string                        `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
}

func (m *RpcDebugPingResponseError) Reset()         { *m = RpcDebugPingResponseError{} }
func (m *RpcDebugPingResponseError) String() string { return proto.CompactTextString(m) }
func (*RpcDebugPingResponseError) ProtoMessage()    {}
func (*RpcDebugPingResponseError) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{0, 26, 6, 1, 0}
}
func (m *RpcDebugPingResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcDebugPingResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcDebugPingResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcDebugPingResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcDebugPingResponseError.Merge(m, src)
}
func (m *RpcDebugPingResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcDebugPingResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcDebugPingResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcDebugPingResponseError proto.InternalMessageInfo

func (m *RpcDebugPingResponseError) GetCode() RpcDebugPingResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcDebugPingResponseError_NULL
}

func (m *RpcDebugPingResponseError) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

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, 27}
}
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, 27, 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, 27, 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, 27, 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, 27, 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 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, 28}
}
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, 28, 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, 28, 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, 28, 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, 28, 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 ""
}

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, 29}
}
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, 29, 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, 29, 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, 29, 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, 29, 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 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, 30}
}
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, 30, 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

type StreamRequest struct {
	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
}

func (m *StreamRequest) Reset()         { *m = StreamRequest{} }
func (m *StreamRequest) String() string { return proto.CompactTextString(m) }
func (*StreamRequest) ProtoMessage()    {}
func (*StreamRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8261c968b2e6f45c, []int{2}
}
func (m *StreamRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StreamRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest.Merge(m, src)
}
func (m *StreamRequest) XXX_Size() int {
	return m.Size()
}
func (m *StreamRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest proto.InternalMessageInfo

func (m *StreamRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

var E_NoAuth = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.MessageOptions)(nil),
	ExtensionType: (*bool)(nil),
	Field:         7777,
	Name:          "anytype.no_auth",
	Tag:           "varint,7777,opt,name=no_auth",
	Filename:      "pb/protos/commands.proto",
}

func init() {
	proto.RegisterEnum("anytype.RpcAppGetVersionResponseErrorCode", RpcAppGetVersionResponseErrorCode_name, RpcAppGetVersionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAppSetDeviceStateRequestDeviceState", RpcAppSetDeviceStateRequestDeviceState_name, RpcAppSetDeviceStateRequestDeviceState_value)
	proto.RegisterEnum("anytype.RpcAppSetDeviceStateResponseErrorCode", RpcAppSetDeviceStateResponseErrorCode_name, RpcAppSetDeviceStateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAppShutdownResponseErrorCode", RpcAppShutdownResponseErrorCode_name, RpcAppShutdownResponseErrorCode_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.RpcWalletCreateSessionResponseErrorCode", RpcWalletCreateSessionResponseErrorCode_name, RpcWalletCreateSessionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWalletCloseSessionResponseErrorCode", RpcWalletCloseSessionResponseErrorCode_name, RpcWalletCloseSessionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountCreateResponseErrorCode", RpcAccountCreateResponseErrorCode_name, RpcAccountCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountRecoverResponseErrorCode", RpcAccountRecoverResponseErrorCode_name, RpcAccountRecoverResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountDeleteResponseErrorCode", RpcAccountDeleteResponseErrorCode_name, RpcAccountDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountSelectResponseErrorCode", RpcAccountSelectResponseErrorCode_name, RpcAccountSelectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountStopResponseErrorCode", RpcAccountStopResponseErrorCode_name, RpcAccountStopResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountMoveResponseErrorCode", RpcAccountMoveResponseErrorCode_name, RpcAccountMoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountConfigUpdateTimezones", RpcAccountConfigUpdateTimezones_name, RpcAccountConfigUpdateTimezones_value)
	proto.RegisterEnum("anytype.RpcAccountConfigUpdateResponseErrorCode", RpcAccountConfigUpdateResponseErrorCode_name, RpcAccountConfigUpdateResponseErrorCode_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.RpcWorkspaceObjectAddResponseErrorCode", RpcWorkspaceObjectAddResponseErrorCode_name, RpcWorkspaceObjectAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceObjectListAddResponseErrorCode", RpcWorkspaceObjectListAddResponseErrorCode_name, RpcWorkspaceObjectListAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceObjectListRemoveResponseErrorCode", RpcWorkspaceObjectListRemoveResponseErrorCode_name, RpcWorkspaceObjectListRemoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceSetIsHighlightedResponseErrorCode", RpcWorkspaceSetIsHighlightedResponseErrorCode_name, RpcWorkspaceSetIsHighlightedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceSelectResponseErrorCode", RpcWorkspaceSelectResponseErrorCode_name, RpcWorkspaceSelectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWorkspaceExportResponseErrorCode", RpcWorkspaceExportResponseErrorCode_name, RpcWorkspaceExportResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectOpenResponseErrorCode", RpcObjectOpenResponseErrorCode_name, RpcObjectOpenResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCloseResponseErrorCode", RpcObjectCloseResponseErrorCode_name, RpcObjectCloseResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectShowResponseErrorCode", RpcObjectShowResponseErrorCode_name, RpcObjectShowResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCreateResponseErrorCode", RpcObjectCreateResponseErrorCode_name, RpcObjectCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCreateBookmarkResponseErrorCode", RpcObjectCreateBookmarkResponseErrorCode_name, RpcObjectCreateBookmarkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCreateRelationResponseErrorCode", RpcObjectCreateRelationResponseErrorCode_name, RpcObjectCreateRelationResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCreateRelationOptionResponseErrorCode", RpcObjectCreateRelationOptionResponseErrorCode_name, RpcObjectCreateRelationOptionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCreateSetResponseErrorCode", RpcObjectCreateSetResponseErrorCode_name, RpcObjectCreateSetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectCreateObjectTypeResponseErrorCode", RpcObjectCreateObjectTypeResponseErrorCode_name, RpcObjectCreateObjectTypeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectBookmarkFetchResponseErrorCode", RpcObjectBookmarkFetchResponseErrorCode_name, RpcObjectBookmarkFetchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectToBookmarkResponseErrorCode", RpcObjectToBookmarkResponseErrorCode_name, RpcObjectToBookmarkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectDuplicateResponseErrorCode", RpcObjectDuplicateResponseErrorCode_name, RpcObjectDuplicateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectOpenBreadcrumbsResponseErrorCode", RpcObjectOpenBreadcrumbsResponseErrorCode_name, RpcObjectOpenBreadcrumbsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSetBreadcrumbsResponseErrorCode", RpcObjectSetBreadcrumbsResponseErrorCode_name, RpcObjectSetBreadcrumbsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectImportMarkdownResponseErrorCode", RpcObjectImportMarkdownResponseErrorCode_name, RpcObjectImportMarkdownResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectShareByLinkResponseErrorCode", RpcObjectShareByLinkResponseErrorCode_name, RpcObjectShareByLinkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectAddWithObjectIdResponseErrorCode", RpcObjectAddWithObjectIdResponseErrorCode_name, RpcObjectAddWithObjectIdResponseErrorCode_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.RpcObjectGroupsSubscribeResponseErrorCode", RpcObjectGroupsSubscribeResponseErrorCode_name, RpcObjectGroupsSubscribeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSubscribeIdsResponseErrorCode", RpcObjectSubscribeIdsResponseErrorCode_name, RpcObjectSubscribeIdsResponseErrorCode_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.RpcObjectSetObjectTypeResponseErrorCode", RpcObjectSetObjectTypeResponseErrorCode_name, RpcObjectSetObjectTypeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSetInternalFlagsResponseErrorCode", RpcObjectSetInternalFlagsResponseErrorCode_name, RpcObjectSetInternalFlagsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectSetDetailsResponseErrorCode", RpcObjectSetDetailsResponseErrorCode_name, RpcObjectSetDetailsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectToSetResponseErrorCode", RpcObjectToSetResponseErrorCode_name, RpcObjectToSetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectUndoResponseErrorCode", RpcObjectUndoResponseErrorCode_name, RpcObjectUndoResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRedoResponseErrorCode", RpcObjectRedoResponseErrorCode_name, RpcObjectRedoResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectListDuplicateResponseErrorCode", RpcObjectListDuplicateResponseErrorCode_name, RpcObjectListDuplicateResponseErrorCode_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.RpcObjectApplyTemplateResponseErrorCode", RpcObjectApplyTemplateResponseErrorCode_name, RpcObjectApplyTemplateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectListExportFormat", RpcObjectListExportFormat_name, RpcObjectListExportFormat_value)
	proto.RegisterEnum("anytype.RpcObjectListExportResponseErrorCode", RpcObjectListExportResponseErrorCode_name, RpcObjectListExportResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectImportRequestMode", RpcObjectImportRequestMode_name, RpcObjectImportRequestMode_value)
	proto.RegisterEnum("anytype.RpcObjectImportRequestType", RpcObjectImportRequestType_name, RpcObjectImportRequestType_value)
	proto.RegisterEnum("anytype.RpcObjectImportResponseErrorCode", RpcObjectImportResponseErrorCode_name, RpcObjectImportResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectImportNotionTokenValidateResponseErrorCode", RpcObjectImportNotionTokenValidateResponseErrorCode_name, RpcObjectImportNotionTokenValidateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectImportListResponseErrorCode", RpcObjectImportListResponseErrorCode_name, RpcObjectImportListResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectImportListImportResponseType", RpcObjectImportListImportResponseType_name, RpcObjectImportListImportResponseType_value)
	proto.RegisterEnum("anytype.RpcObjectRelationAddResponseErrorCode", RpcObjectRelationAddResponseErrorCode_name, RpcObjectRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationDeleteResponseErrorCode", RpcObjectRelationDeleteResponseErrorCode_name, RpcObjectRelationDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationListAvailableResponseErrorCode", RpcObjectRelationListAvailableResponseErrorCode_name, RpcObjectRelationListAvailableResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationAddFeaturedResponseErrorCode", RpcObjectRelationAddFeaturedResponseErrorCode_name, RpcObjectRelationAddFeaturedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectRelationRemoveFeaturedResponseErrorCode", RpcObjectRelationRemoveFeaturedResponseErrorCode_name, RpcObjectRelationRemoveFeaturedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationAddResponseErrorCode", RpcObjectTypeRelationAddResponseErrorCode_name, RpcObjectTypeRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationRemoveResponseErrorCode", RpcObjectTypeRelationRemoveResponseErrorCode_name, RpcObjectTypeRelationRemoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcObjectTypeRelationListResponseErrorCode", RpcObjectTypeRelationListResponseErrorCode_name, RpcObjectTypeRelationListResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcRelationListRemoveOptionResponseErrorCode", RpcRelationListRemoveOptionResponseErrorCode_name, RpcRelationListRemoveOptionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcRelationOptionsResponseErrorCode", RpcRelationOptionsResponseErrorCode_name, RpcRelationOptionsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcHistoryGetVersionsResponseErrorCode", RpcHistoryGetVersionsResponseErrorCode_name, RpcHistoryGetVersionsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcHistoryShowVersionResponseErrorCode", RpcHistoryShowVersionResponseErrorCode_name, RpcHistoryShowVersionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcHistorySetVersionResponseErrorCode", RpcHistorySetVersionResponseErrorCode_name, RpcHistorySetVersionResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileOffloadResponseErrorCode", RpcFileOffloadResponseErrorCode_name, RpcFileOffloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileListOffloadResponseErrorCode", RpcFileListOffloadResponseErrorCode_name, RpcFileListOffloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileUploadResponseErrorCode", RpcFileUploadResponseErrorCode_name, RpcFileUploadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileDownloadResponseErrorCode", RpcFileDownloadResponseErrorCode_name, RpcFileDownloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcFileDropResponseErrorCode", RpcFileDropResponseErrorCode_name, RpcFileDropResponseErrorCode_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.RpcTemplateCreateFromObjectResponseErrorCode", RpcTemplateCreateFromObjectResponseErrorCode_name, RpcTemplateCreateFromObjectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcTemplateCreateFromObjectTypeResponseErrorCode", RpcTemplateCreateFromObjectTypeResponseErrorCode_name, RpcTemplateCreateFromObjectTypeResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcTemplateCloneResponseErrorCode", RpcTemplateCloneResponseErrorCode_name, RpcTemplateCloneResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcTemplateExportAllResponseErrorCode", RpcTemplateExportAllResponseErrorCode_name, RpcTemplateExportAllResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcLinkPreviewResponseErrorCode", RpcLinkPreviewResponseErrorCode_name, RpcLinkPreviewResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcUnsplashSearchResponseErrorCode", RpcUnsplashSearchResponseErrorCode_name, RpcUnsplashSearchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcUnsplashDownloadResponseErrorCode", RpcUnsplashDownloadResponseErrorCode_name, RpcUnsplashDownloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockReplaceResponseErrorCode", RpcBlockReplaceResponseErrorCode_name, RpcBlockReplaceResponseErrorCode_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.RpcBlockUploadResponseErrorCode", RpcBlockUploadResponseErrorCode_name, RpcBlockUploadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDownloadResponseErrorCode", RpcBlockDownloadResponseErrorCode_name, RpcBlockDownloadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCreateResponseErrorCode", RpcBlockCreateResponseErrorCode_name, RpcBlockCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCreateWidgetResponseErrorCode", RpcBlockCreateWidgetResponseErrorCode_name, RpcBlockCreateWidgetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListDeleteResponseErrorCode", RpcBlockListDeleteResponseErrorCode_name, RpcBlockListDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockSetFieldsResponseErrorCode", RpcBlockSetFieldsResponseErrorCode_name, RpcBlockSetFieldsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetAlignResponseErrorCode", RpcBlockListSetAlignResponseErrorCode_name, RpcBlockListSetAlignResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetVerticalAlignResponseErrorCode", RpcBlockListSetVerticalAlignResponseErrorCode_name, RpcBlockListSetVerticalAlignResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetFieldsResponseErrorCode", RpcBlockListSetFieldsResponseErrorCode_name, RpcBlockListSetFieldsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListDuplicateResponseErrorCode", RpcBlockListDuplicateResponseErrorCode_name, RpcBlockListDuplicateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListConvertToObjectsResponseErrorCode", RpcBlockListConvertToObjectsResponseErrorCode_name, RpcBlockListConvertToObjectsResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListMoveToExistingObjectResponseErrorCode", RpcBlockListMoveToExistingObjectResponseErrorCode_name, RpcBlockListMoveToExistingObjectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListMoveToNewObjectResponseErrorCode", RpcBlockListMoveToNewObjectResponseErrorCode_name, RpcBlockListMoveToNewObjectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListTurnIntoResponseErrorCode", RpcBlockListTurnIntoResponseErrorCode_name, RpcBlockListTurnIntoResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockListSetBackgroundColorResponseErrorCode", RpcBlockListSetBackgroundColorResponseErrorCode_name, RpcBlockListSetBackgroundColorResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockExportResponseErrorCode", RpcBlockExportResponseErrorCode_name, RpcBlockExportResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockLatexSetTextResponseErrorCode", RpcBlockLatexSetTextResponseErrorCode_name, RpcBlockLatexSetTextResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextSetTextResponseErrorCode", RpcBlockTextSetTextResponseErrorCode_name, RpcBlockTextSetTextResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextSetColorResponseErrorCode", RpcBlockTextSetColorResponseErrorCode_name, RpcBlockTextSetColorResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextSetMarksGetResponseErrorCode", RpcBlockTextSetMarksGetResponseErrorCode_name, RpcBlockTextSetMarksGetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextSetStyleResponseErrorCode", RpcBlockTextSetStyleResponseErrorCode_name, RpcBlockTextSetStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextSetCheckedResponseErrorCode", RpcBlockTextSetCheckedResponseErrorCode_name, RpcBlockTextSetCheckedResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextSetIconResponseErrorCode", RpcBlockTextSetIconResponseErrorCode_name, RpcBlockTextSetIconResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextListSetStyleResponseErrorCode", RpcBlockTextListSetStyleResponseErrorCode_name, RpcBlockTextListSetStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextListSetColorResponseErrorCode", RpcBlockTextListSetColorResponseErrorCode_name, RpcBlockTextListSetColorResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextListSetMarkResponseErrorCode", RpcBlockTextListSetMarkResponseErrorCode_name, RpcBlockTextListSetMarkResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextListClearStyleResponseErrorCode", RpcBlockTextListClearStyleResponseErrorCode_name, RpcBlockTextListClearStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTextListClearContentResponseErrorCode", RpcBlockTextListClearContentResponseErrorCode_name, RpcBlockTextListClearContentResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableCreateResponseErrorCode", RpcBlockTableCreateResponseErrorCode_name, RpcBlockTableCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableRowCreateResponseErrorCode", RpcBlockTableRowCreateResponseErrorCode_name, RpcBlockTableRowCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableRowSetHeaderResponseErrorCode", RpcBlockTableRowSetHeaderResponseErrorCode_name, RpcBlockTableRowSetHeaderResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableRowListFillResponseErrorCode", RpcBlockTableRowListFillResponseErrorCode_name, RpcBlockTableRowListFillResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableRowListCleanResponseErrorCode", RpcBlockTableRowListCleanResponseErrorCode_name, RpcBlockTableRowListCleanResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableColumnListFillResponseErrorCode", RpcBlockTableColumnListFillResponseErrorCode_name, RpcBlockTableColumnListFillResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableColumnCreateResponseErrorCode", RpcBlockTableColumnCreateResponseErrorCode_name, RpcBlockTableColumnCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableRowDeleteResponseErrorCode", RpcBlockTableRowDeleteResponseErrorCode_name, RpcBlockTableRowDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableColumnDeleteResponseErrorCode", RpcBlockTableColumnDeleteResponseErrorCode_name, RpcBlockTableColumnDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableColumnMoveResponseErrorCode", RpcBlockTableColumnMoveResponseErrorCode_name, RpcBlockTableColumnMoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableRowDuplicateResponseErrorCode", RpcBlockTableRowDuplicateResponseErrorCode_name, RpcBlockTableRowDuplicateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableColumnDuplicateResponseErrorCode", RpcBlockTableColumnDuplicateResponseErrorCode_name, RpcBlockTableColumnDuplicateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableExpandResponseErrorCode", RpcBlockTableExpandResponseErrorCode_name, RpcBlockTableExpandResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockTableSortResponseErrorCode", RpcBlockTableSortResponseErrorCode_name, RpcBlockTableSortResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockFileSetNameResponseErrorCode", RpcBlockFileSetNameResponseErrorCode_name, RpcBlockFileSetNameResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockFileCreateAndUploadResponseErrorCode", RpcBlockFileCreateAndUploadResponseErrorCode_name, RpcBlockFileCreateAndUploadResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockFileListSetStyleResponseErrorCode", RpcBlockFileListSetStyleResponseErrorCode_name, RpcBlockFileListSetStyleResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockImageSetNameResponseErrorCode", RpcBlockImageSetNameResponseErrorCode_name, RpcBlockImageSetNameResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockImageSetWidthResponseErrorCode", RpcBlockImageSetWidthResponseErrorCode_name, RpcBlockImageSetWidthResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockVideoSetNameResponseErrorCode", RpcBlockVideoSetNameResponseErrorCode_name, RpcBlockVideoSetNameResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockVideoSetWidthResponseErrorCode", RpcBlockVideoSetWidthResponseErrorCode_name, RpcBlockVideoSetWidthResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockLinkCreateWithObjectResponseErrorCode", RpcBlockLinkCreateWithObjectResponseErrorCode_name, RpcBlockLinkCreateWithObjectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockLinkListSetAppearanceResponseErrorCode", RpcBlockLinkListSetAppearanceResponseErrorCode_name, RpcBlockLinkListSetAppearanceResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockRelationSetKeyResponseErrorCode", RpcBlockRelationSetKeyResponseErrorCode_name, RpcBlockRelationSetKeyResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockRelationAddResponseErrorCode", RpcBlockRelationAddResponseErrorCode_name, RpcBlockRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockBookmarkFetchResponseErrorCode", RpcBlockBookmarkFetchResponseErrorCode_name, RpcBlockBookmarkFetchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockBookmarkCreateAndFetchResponseErrorCode", RpcBlockBookmarkCreateAndFetchResponseErrorCode_name, RpcBlockBookmarkCreateAndFetchResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDivListSetStyleResponseErrorCode", RpcBlockDivListSetStyleResponseErrorCode_name, RpcBlockDivListSetStyleResponseErrorCode_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.RpcBlockDataviewRelationAddResponseErrorCode", RpcBlockDataviewRelationAddResponseErrorCode_name, RpcBlockDataviewRelationAddResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRelationDeleteResponseErrorCode", RpcBlockDataviewRelationDeleteResponseErrorCode_name, RpcBlockDataviewRelationDeleteResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewRelationListAvailableResponseErrorCode", RpcBlockDataviewRelationListAvailableResponseErrorCode_name, RpcBlockDataviewRelationListAvailableResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewSetSourceResponseErrorCode", RpcBlockDataviewSetSourceResponseErrorCode_name, RpcBlockDataviewSetSourceResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewGroupOrderUpdateResponseErrorCode", RpcBlockDataviewGroupOrderUpdateResponseErrorCode_name, RpcBlockDataviewGroupOrderUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewObjectOrderUpdateResponseErrorCode", RpcBlockDataviewObjectOrderUpdateResponseErrorCode_name, RpcBlockDataviewObjectOrderUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockDataviewCreateBookmarkResponseErrorCode", RpcBlockDataviewCreateBookmarkResponseErrorCode_name, RpcBlockDataviewCreateBookmarkResponseErrorCode_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.RpcDebugExportLocalstoreResponseErrorCode", RpcDebugExportLocalstoreResponseErrorCode_name, RpcDebugExportLocalstoreResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcDebugPingResponseErrorCode", RpcDebugPingResponseErrorCode_name, RpcDebugPingResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcMetricsSetParametersResponseErrorCode", RpcMetricsSetParametersResponseErrorCode_name, RpcMetricsSetParametersResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcLogSendRequestLevel", RpcLogSendRequestLevel_name, RpcLogSendRequestLevel_value)
	proto.RegisterEnum("anytype.RpcLogSendResponseErrorCode", RpcLogSendResponseErrorCode_name, RpcLogSendResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcProcessCancelResponseErrorCode", RpcProcessCancelResponseErrorCode_name, RpcProcessCancelResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcGenericErrorResponseErrorCode", RpcGenericErrorResponseErrorCode_name, RpcGenericErrorResponseErrorCode_value)
	proto.RegisterType((*Rpc)(nil), "anytype.Rpc")
	proto.RegisterType((*RpcApp)(nil), "anytype.Rpc.App")
	proto.RegisterType((*RpcAppGetVersion)(nil), "anytype.Rpc.App.GetVersion")
	proto.RegisterType((*RpcAppGetVersionRequest)(nil), "anytype.Rpc.App.GetVersion.Request")
	proto.RegisterType((*RpcAppGetVersionResponse)(nil), "anytype.Rpc.App.GetVersion.Response")
	proto.RegisterType((*RpcAppGetVersionResponseError)(nil), "anytype.Rpc.App.GetVersion.Response.Error")
	proto.RegisterType((*RpcAppSetDeviceState)(nil), "anytype.Rpc.App.SetDeviceState")
	proto.RegisterType((*RpcAppSetDeviceStateRequest)(nil), "anytype.Rpc.App.SetDeviceState.Request")
	proto.RegisterType((*RpcAppSetDeviceStateResponse)(nil), "anytype.Rpc.App.SetDeviceState.Response")
	proto.RegisterType((*RpcAppSetDeviceStateResponseError)(nil), "anytype.Rpc.App.SetDeviceState.Response.Error")
	proto.RegisterType((*RpcAppShutdown)(nil), "anytype.Rpc.App.Shutdown")
	proto.RegisterType((*RpcAppShutdownRequest)(nil), "anytype.Rpc.App.Shutdown.Request")
	proto.RegisterType((*RpcAppShutdownResponse)(nil), "anytype.Rpc.App.Shutdown.Response")
	proto.RegisterType((*RpcAppShutdownResponseError)(nil), "anytype.Rpc.App.Shutdown.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((*RpcWalletCreateSession)(nil), "anytype.Rpc.Wallet.CreateSession")
	proto.RegisterType((*RpcWalletCreateSessionRequest)(nil), "anytype.Rpc.Wallet.CreateSession.Request")
	proto.RegisterType((*RpcWalletCreateSessionResponse)(nil), "anytype.Rpc.Wallet.CreateSession.Response")
	proto.RegisterType((*RpcWalletCreateSessionResponseError)(nil), "anytype.Rpc.Wallet.CreateSession.Response.Error")
	proto.RegisterType((*RpcWalletCloseSession)(nil), "anytype.Rpc.Wallet.CloseSession")
	proto.RegisterType((*RpcWalletCloseSessionRequest)(nil), "anytype.Rpc.Wallet.CloseSession.Request")
	proto.RegisterType((*RpcWalletCloseSessionResponse)(nil), "anytype.Rpc.Wallet.CloseSession.Response")
	proto.RegisterType((*RpcWalletCloseSessionResponseError)(nil), "anytype.Rpc.Wallet.CloseSession.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((*RpcAccountDelete)(nil), "anytype.Rpc.Account.Delete")
	proto.RegisterType((*RpcAccountDeleteRequest)(nil), "anytype.Rpc.Account.Delete.Request")
	proto.RegisterType((*RpcAccountDeleteResponse)(nil), "anytype.Rpc.Account.Delete.Response")
	proto.RegisterType((*RpcAccountDeleteResponseError)(nil), "anytype.Rpc.Account.Delete.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((*RpcAccountMove)(nil), "anytype.Rpc.Account.Move")
	proto.RegisterType((*RpcAccountMoveRequest)(nil), "anytype.Rpc.Account.Move.Request")
	proto.RegisterType((*RpcAccountMoveResponse)(nil), "anytype.Rpc.Account.Move.Response")
	proto.RegisterType((*RpcAccountMoveResponseError)(nil), "anytype.Rpc.Account.Move.Response.Error")
	proto.RegisterType((*RpcAccountConfigUpdate)(nil), "anytype.Rpc.Account.ConfigUpdate")
	proto.RegisterType((*RpcAccountConfigUpdateRequest)(nil), "anytype.Rpc.Account.ConfigUpdate.Request")
	proto.RegisterType((*RpcAccountConfigUpdateResponse)(nil), "anytype.Rpc.Account.ConfigUpdate.Response")
	proto.RegisterType((*RpcAccountConfigUpdateResponseError)(nil), "anytype.Rpc.Account.ConfigUpdate.Response.Error")
	proto.RegisterType((*RpcAccountGetConfig)(nil), "anytype.Rpc.Account.GetConfig")
	proto.RegisterType((*RpcAccountGetConfigGet)(nil), "anytype.Rpc.Account.GetConfig.Get")
	proto.RegisterType((*RpcAccountGetConfigGetRequest)(nil), "anytype.Rpc.Account.GetConfig.Get.Request")
	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((*RpcWorkspaceObject)(nil), "anytype.Rpc.Workspace.Object")
	proto.RegisterType((*RpcWorkspaceObjectAdd)(nil), "anytype.Rpc.Workspace.Object.Add")
	proto.RegisterType((*RpcWorkspaceObjectAddRequest)(nil), "anytype.Rpc.Workspace.Object.Add.Request")
	proto.RegisterType((*RpcWorkspaceObjectAddResponse)(nil), "anytype.Rpc.Workspace.Object.Add.Response")
	proto.RegisterType((*RpcWorkspaceObjectAddResponseError)(nil), "anytype.Rpc.Workspace.Object.Add.Response.Error")
	proto.RegisterType((*RpcWorkspaceObjectListAdd)(nil), "anytype.Rpc.Workspace.Object.ListAdd")
	proto.RegisterType((*RpcWorkspaceObjectListAddRequest)(nil), "anytype.Rpc.Workspace.Object.ListAdd.Request")
	proto.RegisterType((*RpcWorkspaceObjectListAddResponse)(nil), "anytype.Rpc.Workspace.Object.ListAdd.Response")
	proto.RegisterType((*RpcWorkspaceObjectListAddResponseError)(nil), "anytype.Rpc.Workspace.Object.ListAdd.Response.Error")
	proto.RegisterType((*RpcWorkspaceObjectListRemove)(nil), "anytype.Rpc.Workspace.Object.ListRemove")
	proto.RegisterType((*RpcWorkspaceObjectListRemoveRequest)(nil), "anytype.Rpc.Workspace.Object.ListRemove.Request")
	proto.RegisterType((*RpcWorkspaceObjectListRemoveResponse)(nil), "anytype.Rpc.Workspace.Object.ListRemove.Response")
	proto.RegisterType((*RpcWorkspaceObjectListRemoveResponseError)(nil), "anytype.Rpc.Workspace.Object.ListRemove.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((*RpcWorkspaceExport)(nil), "anytype.Rpc.Workspace.Export")
	proto.RegisterType((*RpcWorkspaceExportRequest)(nil), "anytype.Rpc.Workspace.Export.Request")
	proto.RegisterType((*RpcWorkspaceExportResponse)(nil), "anytype.Rpc.Workspace.Export.Response")
	proto.RegisterType((*RpcWorkspaceExportResponseError)(nil), "anytype.Rpc.Workspace.Export.Response.Error")
	proto.RegisterType((*RpcObject)(nil), "anytype.Rpc.Object")
	proto.RegisterType((*RpcObjectOpen)(nil), "anytype.Rpc.Object.Open")
	proto.RegisterType((*RpcObjectOpenRequest)(nil), "anytype.Rpc.Object.Open.Request")
	proto.RegisterType((*RpcObjectOpenResponse)(nil), "anytype.Rpc.Object.Open.Response")
	proto.RegisterType((*RpcObjectOpenResponseError)(nil), "anytype.Rpc.Object.Open.Response.Error")
	proto.RegisterType((*RpcObjectClose)(nil), "anytype.Rpc.Object.Close")
	proto.RegisterType((*RpcObjectCloseRequest)(nil), "anytype.Rpc.Object.Close.Request")
	proto.RegisterType((*RpcObjectCloseResponse)(nil), "anytype.Rpc.Object.Close.Response")
	proto.RegisterType((*RpcObjectCloseResponseError)(nil), "anytype.Rpc.Object.Close.Response.Error")
	proto.RegisterType((*RpcObjectShow)(nil), "anytype.Rpc.Object.Show")
	proto.RegisterType((*RpcObjectShowRequest)(nil), "anytype.Rpc.Object.Show.Request")
	proto.RegisterType((*RpcObjectShowResponse)(nil), "anytype.Rpc.Object.Show.Response")
	proto.RegisterType((*RpcObjectShowResponseError)(nil), "anytype.Rpc.Object.Show.Response.Error")
	proto.RegisterType((*RpcObjectCreate)(nil), "anytype.Rpc.Object.Create")
	proto.RegisterType((*RpcObjectCreateRequest)(nil), "anytype.Rpc.Object.Create.Request")
	proto.RegisterType((*RpcObjectCreateResponse)(nil), "anytype.Rpc.Object.Create.Response")
	proto.RegisterType((*RpcObjectCreateResponseError)(nil), "anytype.Rpc.Object.Create.Response.Error")
	proto.RegisterType((*RpcObjectCreateBookmark)(nil), "anytype.Rpc.Object.CreateBookmark")
	proto.RegisterType((*RpcObjectCreateBookmarkRequest)(nil), "anytype.Rpc.Object.CreateBookmark.Request")
	proto.RegisterType((*RpcObjectCreateBookmarkResponse)(nil), "anytype.Rpc.Object.CreateBookmark.Response")
	proto.RegisterType((*RpcObjectCreateBookmarkResponseError)(nil), "anytype.Rpc.Object.CreateBookmark.Response.Error")
	proto.RegisterType((*RpcObjectCreateRelation)(nil), "anytype.Rpc.Object.CreateRelation")
	proto.RegisterType((*RpcObjectCreateRelationRequest)(nil), "anytype.Rpc.Object.CreateRelation.Request")
	proto.RegisterType((*RpcObjectCreateRelationResponse)(nil), "anytype.Rpc.Object.CreateRelation.Response")
	proto.RegisterType((*RpcObjectCreateRelationResponseError)(nil), "anytype.Rpc.Object.CreateRelation.Response.Error")
	proto.RegisterType((*RpcObjectCreateRelationOption)(nil), "anytype.Rpc.Object.CreateRelationOption")
	proto.RegisterType((*RpcObjectCreateRelationOptionRequest)(nil), "anytype.Rpc.Object.CreateRelationOption.Request")
	proto.RegisterType((*RpcObjectCreateRelationOptionResponse)(nil), "anytype.Rpc.Object.CreateRelationOption.Response")
	proto.RegisterType((*RpcObjectCreateRelationOptionResponseError)(nil), "anytype.Rpc.Object.CreateRelationOption.Response.Error")
	proto.RegisterType((*RpcObjectCreateSet)(nil), "anytype.Rpc.Object.CreateSet")
	proto.RegisterType((*RpcObjectCreateSetRequest)(nil), "anytype.Rpc.Object.CreateSet.Request")
	proto.RegisterType((*RpcObjectCreateSetResponse)(nil), "anytype.Rpc.Object.CreateSet.Response")
	proto.RegisterType((*RpcObjectCreateSetResponseError)(nil), "anytype.Rpc.Object.CreateSet.Response.Error")
	proto.RegisterType((*RpcObjectCreateObjectType)(nil), "anytype.Rpc.Object.CreateObjectType")
	proto.RegisterType((*RpcObjectCreateObjectTypeRequest)(nil), "anytype.Rpc.Object.CreateObjectType.Request")
	proto.RegisterType((*RpcObjectCreateObjectTypeResponse)(nil), "anytype.Rpc.Object.CreateObjectType.Response")
	proto.RegisterType((*RpcObjectCreateObjectTypeResponseError)(nil), "anytype.Rpc.Object.CreateObjectType.Response.Error")
	proto.RegisterType((*RpcObjectBookmarkFetch)(nil), "anytype.Rpc.Object.BookmarkFetch")
	proto.RegisterType((*RpcObjectBookmarkFetchRequest)(nil), "anytype.Rpc.Object.BookmarkFetch.Request")
	proto.RegisterType((*RpcObjectBookmarkFetchResponse)(nil), "anytype.Rpc.Object.BookmarkFetch.Response")
	proto.RegisterType((*RpcObjectBookmarkFetchResponseError)(nil), "anytype.Rpc.Object.BookmarkFetch.Response.Error")
	proto.RegisterType((*RpcObjectToBookmark)(nil), "anytype.Rpc.Object.ToBookmark")
	proto.RegisterType((*RpcObjectToBookmarkRequest)(nil), "anytype.Rpc.Object.ToBookmark.Request")
	proto.RegisterType((*RpcObjectToBookmarkResponse)(nil), "anytype.Rpc.Object.ToBookmark.Response")
	proto.RegisterType((*RpcObjectToBookmarkResponseError)(nil), "anytype.Rpc.Object.ToBookmark.Response.Error")
	proto.RegisterType((*RpcObjectDuplicate)(nil), "anytype.Rpc.Object.Duplicate")
	proto.RegisterType((*RpcObjectDuplicateRequest)(nil), "anytype.Rpc.Object.Duplicate.Request")
	proto.RegisterType((*RpcObjectDuplicateResponse)(nil), "anytype.Rpc.Object.Duplicate.Response")
	proto.RegisterType((*RpcObjectDuplicateResponseError)(nil), "anytype.Rpc.Object.Duplicate.Response.Error")
	proto.RegisterType((*RpcObjectOpenBreadcrumbs)(nil), "anytype.Rpc.Object.OpenBreadcrumbs")
	proto.RegisterType((*RpcObjectOpenBreadcrumbsRequest)(nil), "anytype.Rpc.Object.OpenBreadcrumbs.Request")
	proto.RegisterType((*RpcObjectOpenBreadcrumbsResponse)(nil), "anytype.Rpc.Object.OpenBreadcrumbs.Response")
	proto.RegisterType((*RpcObjectOpenBreadcrumbsResponseError)(nil), "anytype.Rpc.Object.OpenBreadcrumbs.Response.Error")
	proto.RegisterType((*RpcObjectSetBreadcrumbs)(nil), "anytype.Rpc.Object.SetBreadcrumbs")
	proto.RegisterType((*RpcObjectSetBreadcrumbsRequest)(nil), "anytype.Rpc.Object.SetBreadcrumbs.Request")
	proto.RegisterType((*RpcObjectSetBreadcrumbsResponse)(nil), "anytype.Rpc.Object.SetBreadcrumbs.Response")
	proto.RegisterType((*RpcObjectSetBreadcrumbsResponseError)(nil), "anytype.Rpc.Object.SetBreadcrumbs.Response.Error")
	proto.RegisterType((*RpcObjectImportMarkdown)(nil), "anytype.Rpc.Object.ImportMarkdown")
	proto.RegisterType((*RpcObjectImportMarkdownRequest)(nil), "anytype.Rpc.Object.ImportMarkdown.Request")
	proto.RegisterType((*RpcObjectImportMarkdownResponse)(nil), "anytype.Rpc.Object.ImportMarkdown.Response")
	proto.RegisterType((*RpcObjectImportMarkdownResponseError)(nil), "anytype.Rpc.Object.ImportMarkdown.Response.Error")
	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((*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((*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((*RpcObjectGroupsSubscribe)(nil), "anytype.Rpc.Object.GroupsSubscribe")
	proto.RegisterType((*RpcObjectGroupsSubscribeRequest)(nil), "anytype.Rpc.Object.GroupsSubscribe.Request")
	proto.RegisterType((*RpcObjectGroupsSubscribeResponse)(nil), "anytype.Rpc.Object.GroupsSubscribe.Response")
	proto.RegisterType((*RpcObjectGroupsSubscribeResponseError)(nil), "anytype.Rpc.Object.GroupsSubscribe.Response.Error")
	proto.RegisterType((*RpcObjectSubscribeIds)(nil), "anytype.Rpc.Object.SubscribeIds")
	proto.RegisterType((*RpcObjectSubscribeIdsRequest)(nil), "anytype.Rpc.Object.SubscribeIds.Request")
	proto.RegisterType((*RpcObjectSubscribeIdsResponse)(nil), "anytype.Rpc.Object.SubscribeIds.Response")
	proto.RegisterType((*RpcObjectSubscribeIdsResponseError)(nil), "anytype.Rpc.Object.SubscribeIds.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((*RpcObjectSetObjectType)(nil), "anytype.Rpc.Object.SetObjectType")
	proto.RegisterType((*RpcObjectSetObjectTypeRequest)(nil), "anytype.Rpc.Object.SetObjectType.Request")
	proto.RegisterType((*RpcObjectSetObjectTypeResponse)(nil), "anytype.Rpc.Object.SetObjectType.Response")
	proto.RegisterType((*RpcObjectSetObjectTypeResponseError)(nil), "anytype.Rpc.Object.SetObjectType.Response.Error")
	proto.RegisterType((*RpcObjectSetInternalFlags)(nil), "anytype.Rpc.Object.SetInternalFlags")
	proto.RegisterType((*RpcObjectSetInternalFlagsRequest)(nil), "anytype.Rpc.Object.SetInternalFlags.Request")
	proto.RegisterType((*RpcObjectSetInternalFlagsResponse)(nil), "anytype.Rpc.Object.SetInternalFlags.Response")
	proto.RegisterType((*RpcObjectSetInternalFlagsResponseError)(nil), "anytype.Rpc.Object.SetInternalFlags.Response.Error")
	proto.RegisterType((*RpcObjectSetDetails)(nil), "anytype.Rpc.Object.SetDetails")
	proto.RegisterType((*RpcObjectSetDetailsDetail)(nil), "anytype.Rpc.Object.SetDetails.Detail")
	proto.RegisterType((*RpcObjectSetDetailsRequest)(nil), "anytype.Rpc.Object.SetDetails.Request")
	proto.RegisterType((*RpcObjectSetDetailsResponse)(nil), "anytype.Rpc.Object.SetDetails.Response")
	proto.RegisterType((*RpcObjectSetDetailsResponseError)(nil), "anytype.Rpc.Object.SetDetails.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((*RpcObjectUndoRedoCounter)(nil), "anytype.Rpc.Object.UndoRedoCounter")
	proto.RegisterType((*RpcObjectUndo)(nil), "anytype.Rpc.Object.Undo")
	proto.RegisterType((*RpcObjectUndoRequest)(nil), "anytype.Rpc.Object.Undo.Request")
	proto.RegisterType((*RpcObjectUndoResponse)(nil), "anytype.Rpc.Object.Undo.Response")
	proto.RegisterType((*RpcObjectUndoResponseError)(nil), "anytype.Rpc.Object.Undo.Response.Error")
	proto.RegisterType((*RpcObjectRedo)(nil), "anytype.Rpc.Object.Redo")
	proto.RegisterType((*RpcObjectRedoRequest)(nil), "anytype.Rpc.Object.Redo.Request")
	proto.RegisterType((*RpcObjectRedoResponse)(nil), "anytype.Rpc.Object.Redo.Response")
	proto.RegisterType((*RpcObjectRedoResponseError)(nil), "anytype.Rpc.Object.Redo.Response.Error")
	proto.RegisterType((*RpcObjectListDuplicate)(nil), "anytype.Rpc.Object.ListDuplicate")
	proto.RegisterType((*RpcObjectListDuplicateRequest)(nil), "anytype.Rpc.Object.ListDuplicate.Request")
	proto.RegisterType((*RpcObjectListDuplicateResponse)(nil), "anytype.Rpc.Object.ListDuplicate.Response")
	proto.RegisterType((*RpcObjectListDuplicateResponseError)(nil), "anytype.Rpc.Object.ListDuplicate.Response.Error")
	proto.RegisterType((*RpcObjectListDelete)(nil), "anytype.Rpc.Object.ListDelete")
	proto.RegisterType((*RpcObjectListDeleteRequest)(nil), "anytype.Rpc.Object.ListDelete.Request")
	proto.RegisterType((*RpcObjectListDeleteResponse)(nil), "anytype.Rpc.Object.ListDelete.Response")
	proto.RegisterType((*RpcObjectListDeleteResponseError)(nil), "anytype.Rpc.Object.ListDelete.Response.Error")
	proto.RegisterType((*RpcObjectListSetIsArchived)(nil), "anytype.Rpc.Object.ListSetIsArchived")
	proto.RegisterType((*RpcObjectListSetIsArchivedRequest)(nil), "anytype.Rpc.Object.ListSetIsArchived.Request")
	proto.RegisterType((*RpcObjectListSetIsArchivedResponse)(nil), "anytype.Rpc.Object.ListSetIsArchived.Response")
	proto.RegisterType((*RpcObjectListSetIsArchivedResponseError)(nil), "anytype.Rpc.Object.ListSetIsArchived.Response.Error")
	proto.RegisterType((*RpcObjectListSetIsFavorite)(nil), "anytype.Rpc.Object.ListSetIsFavorite")
	proto.RegisterType((*RpcObjectListSetIsFavoriteRequest)(nil), "anytype.Rpc.Object.ListSetIsFavorite.Request")
	proto.RegisterType((*RpcObjectListSetIsFavoriteResponse)(nil), "anytype.Rpc.Object.ListSetIsFavorite.Response")
	proto.RegisterType((*RpcObjectListSetIsFavoriteResponseError)(nil), "anytype.Rpc.Object.ListSetIsFavorite.Response.Error")
	proto.RegisterType((*RpcObjectApplyTemplate)(nil), "anytype.Rpc.Object.ApplyTemplate")
	proto.RegisterType((*RpcObjectApplyTemplateRequest)(nil), "anytype.Rpc.Object.ApplyTemplate.Request")
	proto.RegisterType((*RpcObjectApplyTemplateResponse)(nil), "anytype.Rpc.Object.ApplyTemplate.Response")
	proto.RegisterType((*RpcObjectApplyTemplateResponseError)(nil), "anytype.Rpc.Object.ApplyTemplate.Response.Error")
	proto.RegisterType((*RpcObjectListExport)(nil), "anytype.Rpc.Object.ListExport")
	proto.RegisterType((*RpcObjectListExportRequest)(nil), "anytype.Rpc.Object.ListExport.Request")
	proto.RegisterType((*RpcObjectListExportResponse)(nil), "anytype.Rpc.Object.ListExport.Response")
	proto.RegisterType((*RpcObjectListExportResponseError)(nil), "anytype.Rpc.Object.ListExport.Response.Error")
	proto.RegisterType((*RpcObjectImport)(nil), "anytype.Rpc.Object.Import")
	proto.RegisterType((*RpcObjectImportRequest)(nil), "anytype.Rpc.Object.Import.Request")
	proto.RegisterType((*RpcObjectImportRequestNotionParams)(nil), "anytype.Rpc.Object.Import.Request.NotionParams")
	proto.RegisterType((*RpcObjectImportRequestMarkdownParams)(nil), "anytype.Rpc.Object.Import.Request.MarkdownParams")
	proto.RegisterType((*RpcObjectImportRequestBookmarksParams)(nil), "anytype.Rpc.Object.Import.Request.BookmarksParams")
	proto.RegisterType((*RpcObjectImportRequestSnapshot)(nil), "anytype.Rpc.Object.Import.Request.Snapshot")
	proto.RegisterType((*RpcObjectImportResponse)(nil), "anytype.Rpc.Object.Import.Response")
	proto.RegisterType((*RpcObjectImportResponseError)(nil), "anytype.Rpc.Object.Import.Response.Error")
	proto.RegisterType((*RpcObjectImportNotion)(nil), "anytype.Rpc.Object.Import.Notion")
	proto.RegisterType((*RpcObjectImportNotionTokenValidate)(nil), "anytype.Rpc.Object.Import.Notion.TokenValidate")
	proto.RegisterType((*RpcObjectImportNotionTokenValidateRequest)(nil), "anytype.Rpc.Object.Import.Notion.TokenValidate.Request")
	proto.RegisterType((*RpcObjectImportNotionTokenValidateResponse)(nil), "anytype.Rpc.Object.Import.Notion.TokenValidate.Response")
	proto.RegisterType((*RpcObjectImportNotionTokenValidateResponseError)(nil), "anytype.Rpc.Object.Import.Notion.TokenValidate.Response.Error")
	proto.RegisterType((*RpcObjectImportList)(nil), "anytype.Rpc.Object.ImportList")
	proto.RegisterType((*RpcObjectImportListRequest)(nil), "anytype.Rpc.Object.ImportList.Request")
	proto.RegisterType((*RpcObjectImportListResponse)(nil), "anytype.Rpc.Object.ImportList.Response")
	proto.RegisterType((*RpcObjectImportListResponseError)(nil), "anytype.Rpc.Object.ImportList.Response.Error")
	proto.RegisterType((*RpcObjectImportListImportResponse)(nil), "anytype.Rpc.Object.ImportList.ImportResponse")
	proto.RegisterType((*RpcObjectRelation)(nil), "anytype.Rpc.ObjectRelation")
	proto.RegisterType((*RpcObjectRelationAdd)(nil), "anytype.Rpc.ObjectRelation.Add")
	proto.RegisterType((*RpcObjectRelationAddRequest)(nil), "anytype.Rpc.ObjectRelation.Add.Request")
	proto.RegisterType((*RpcObjectRelationAddResponse)(nil), "anytype.Rpc.ObjectRelation.Add.Response")
	proto.RegisterType((*RpcObjectRelationAddResponseError)(nil), "anytype.Rpc.ObjectRelation.Add.Response.Error")
	proto.RegisterType((*RpcObjectRelationDelete)(nil), "anytype.Rpc.ObjectRelation.Delete")
	proto.RegisterType((*RpcObjectRelationDeleteRequest)(nil), "anytype.Rpc.ObjectRelation.Delete.Request")
	proto.RegisterType((*RpcObjectRelationDeleteResponse)(nil), "anytype.Rpc.ObjectRelation.Delete.Response")
	proto.RegisterType((*RpcObjectRelationDeleteResponseError)(nil), "anytype.Rpc.ObjectRelation.Delete.Response.Error")
	proto.RegisterType((*RpcObjectRelationListAvailable)(nil), "anytype.Rpc.ObjectRelation.ListAvailable")
	proto.RegisterType((*RpcObjectRelationListAvailableRequest)(nil), "anytype.Rpc.ObjectRelation.ListAvailable.Request")
	proto.RegisterType((*RpcObjectRelationListAvailableResponse)(nil), "anytype.Rpc.ObjectRelation.ListAvailable.Response")
	proto.RegisterType((*RpcObjectRelationListAvailableResponseError)(nil), "anytype.Rpc.ObjectRelation.ListAvailable.Response.Error")
	proto.RegisterType((*RpcObjectRelationAddFeatured)(nil), "anytype.Rpc.ObjectRelation.AddFeatured")
	proto.RegisterType((*RpcObjectRelationAddFeaturedRequest)(nil), "anytype.Rpc.ObjectRelation.AddFeatured.Request")
	proto.RegisterType((*RpcObjectRelationAddFeaturedResponse)(nil), "anytype.Rpc.ObjectRelation.AddFeatured.Response")
	proto.RegisterType((*RpcObjectRelationAddFeaturedResponseError)(nil), "anytype.Rpc.ObjectRelation.AddFeatured.Response.Error")
	proto.RegisterType((*RpcObjectRelationRemoveFeatured)(nil), "anytype.Rpc.ObjectRelation.RemoveFeatured")
	proto.RegisterType((*RpcObjectRelationRemoveFeaturedRequest)(nil), "anytype.Rpc.ObjectRelation.RemoveFeatured.Request")
	proto.RegisterType((*RpcObjectRelationRemoveFeaturedResponse)(nil), "anytype.Rpc.ObjectRelation.RemoveFeatured.Response")
	proto.RegisterType((*RpcObjectRelationRemoveFeaturedResponseError)(nil), "anytype.Rpc.ObjectRelation.RemoveFeatured.Response.Error")
	proto.RegisterType((*RpcObjectType)(nil), "anytype.Rpc.ObjectType")
	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((*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((*RpcRelation)(nil), "anytype.Rpc.Relation")
	proto.RegisterType((*RpcRelationListRemoveOption)(nil), "anytype.Rpc.Relation.ListRemoveOption")
	proto.RegisterType((*RpcRelationListRemoveOptionRequest)(nil), "anytype.Rpc.Relation.ListRemoveOption.Request")
	proto.RegisterType((*RpcRelationListRemoveOptionResponse)(nil), "anytype.Rpc.Relation.ListRemoveOption.Response")
	proto.RegisterType((*RpcRelationListRemoveOptionResponseError)(nil), "anytype.Rpc.Relation.ListRemoveOption.Response.Error")
	proto.RegisterType((*RpcRelationOptions)(nil), "anytype.Rpc.Relation.Options")
	proto.RegisterType((*RpcRelationOptionsRequest)(nil), "anytype.Rpc.Relation.Options.Request")
	proto.RegisterType((*RpcRelationOptionsResponse)(nil), "anytype.Rpc.Relation.Options.Response")
	proto.RegisterType((*RpcRelationOptionsResponseError)(nil), "anytype.Rpc.Relation.Options.Response.Error")
	proto.RegisterType((*RpcHistory)(nil), "anytype.Rpc.History")
	proto.RegisterType((*RpcHistoryVersion)(nil), "anytype.Rpc.History.Version")
	proto.RegisterType((*RpcHistoryGetVersions)(nil), "anytype.Rpc.History.GetVersions")
	proto.RegisterType((*RpcHistoryGetVersionsRequest)(nil), "anytype.Rpc.History.GetVersions.Request")
	proto.RegisterType((*RpcHistoryGetVersionsResponse)(nil), "anytype.Rpc.History.GetVersions.Response")
	proto.RegisterType((*RpcHistoryGetVersionsResponseError)(nil), "anytype.Rpc.History.GetVersions.Response.Error")
	proto.RegisterType((*RpcHistoryShowVersion)(nil), "anytype.Rpc.History.ShowVersion")
	proto.RegisterType((*RpcHistoryShowVersionRequest)(nil), "anytype.Rpc.History.ShowVersion.Request")
	proto.RegisterType((*RpcHistoryShowVersionResponse)(nil), "anytype.Rpc.History.ShowVersion.Response")
	proto.RegisterType((*RpcHistoryShowVersionResponseError)(nil), "anytype.Rpc.History.ShowVersion.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((*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((*RpcFileListOffload)(nil), "anytype.Rpc.File.ListOffload")
	proto.RegisterType((*RpcFileListOffloadRequest)(nil), "anytype.Rpc.File.ListOffload.Request")
	proto.RegisterType((*RpcFileListOffloadResponse)(nil), "anytype.Rpc.File.ListOffload.Response")
	proto.RegisterType((*RpcFileListOffloadResponseError)(nil), "anytype.Rpc.File.ListOffload.Response.Error")
	proto.RegisterType((*RpcFileUpload)(nil), "anytype.Rpc.File.Upload")
	proto.RegisterType((*RpcFileUploadRequest)(nil), "anytype.Rpc.File.Upload.Request")
	proto.RegisterType((*RpcFileUploadResponse)(nil), "anytype.Rpc.File.Upload.Response")
	proto.RegisterType((*RpcFileUploadResponseError)(nil), "anytype.Rpc.File.Upload.Response.Error")
	proto.RegisterType((*RpcFileDownload)(nil), "anytype.Rpc.File.Download")
	proto.RegisterType((*RpcFileDownloadRequest)(nil), "anytype.Rpc.File.Download.Request")
	proto.RegisterType((*RpcFileDownloadResponse)(nil), "anytype.Rpc.File.Download.Response")
	proto.RegisterType((*RpcFileDownloadResponseError)(nil), "anytype.Rpc.File.Download.Response.Error")
	proto.RegisterType((*RpcFileDrop)(nil), "anytype.Rpc.File.Drop")
	proto.RegisterType((*RpcFileDropRequest)(nil), "anytype.Rpc.File.Drop.Request")
	proto.RegisterType((*RpcFileDropResponse)(nil), "anytype.Rpc.File.Drop.Response")
	proto.RegisterType((*RpcFileDropResponseError)(nil), "anytype.Rpc.File.Drop.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((*RpcTemplate)(nil), "anytype.Rpc.Template")
	proto.RegisterType((*RpcTemplateCreateFromObject)(nil), "anytype.Rpc.Template.CreateFromObject")
	proto.RegisterType((*RpcTemplateCreateFromObjectRequest)(nil), "anytype.Rpc.Template.CreateFromObject.Request")
	proto.RegisterType((*RpcTemplateCreateFromObjectResponse)(nil), "anytype.Rpc.Template.CreateFromObject.Response")
	proto.RegisterType((*RpcTemplateCreateFromObjectResponseError)(nil), "anytype.Rpc.Template.CreateFromObject.Response.Error")
	proto.RegisterType((*RpcTemplateCreateFromObjectType)(nil), "anytype.Rpc.Template.CreateFromObjectType")
	proto.RegisterType((*RpcTemplateCreateFromObjectTypeRequest)(nil), "anytype.Rpc.Template.CreateFromObjectType.Request")
	proto.RegisterType((*RpcTemplateCreateFromObjectTypeResponse)(nil), "anytype.Rpc.Template.CreateFromObjectType.Response")
	proto.RegisterType((*RpcTemplateCreateFromObjectTypeResponseError)(nil), "anytype.Rpc.Template.CreateFromObjectType.Response.Error")
	proto.RegisterType((*RpcTemplateClone)(nil), "anytype.Rpc.Template.Clone")
	proto.RegisterType((*RpcTemplateCloneRequest)(nil), "anytype.Rpc.Template.Clone.Request")
	proto.RegisterType((*RpcTemplateCloneResponse)(nil), "anytype.Rpc.Template.Clone.Response")
	proto.RegisterType((*RpcTemplateCloneResponseError)(nil), "anytype.Rpc.Template.Clone.Response.Error")
	proto.RegisterType((*RpcTemplateExportAll)(nil), "anytype.Rpc.Template.ExportAll")
	proto.RegisterType((*RpcTemplateExportAllRequest)(nil), "anytype.Rpc.Template.ExportAll.Request")
	proto.RegisterType((*RpcTemplateExportAllResponse)(nil), "anytype.Rpc.Template.ExportAll.Response")
	proto.RegisterType((*RpcTemplateExportAllResponseError)(nil), "anytype.Rpc.Template.ExportAll.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((*RpcUnsplash)(nil), "anytype.Rpc.Unsplash")
	proto.RegisterType((*RpcUnsplashSearch)(nil), "anytype.Rpc.Unsplash.Search")
	proto.RegisterType((*RpcUnsplashSearchRequest)(nil), "anytype.Rpc.Unsplash.Search.Request")
	proto.RegisterType((*RpcUnsplashSearchResponse)(nil), "anytype.Rpc.Unsplash.Search.Response")
	proto.RegisterType((*RpcUnsplashSearchResponsePicture)(nil), "anytype.Rpc.Unsplash.Search.Response.Picture")
	proto.RegisterType((*RpcUnsplashSearchResponseError)(nil), "anytype.Rpc.Unsplash.Search.Response.Error")
	proto.RegisterType((*RpcUnsplashDownload)(nil), "anytype.Rpc.Unsplash.Download")
	proto.RegisterType((*RpcUnsplashDownloadRequest)(nil), "anytype.Rpc.Unsplash.Download.Request")
	proto.RegisterType((*RpcUnsplashDownloadResponse)(nil), "anytype.Rpc.Unsplash.Download.Response")
	proto.RegisterType((*RpcUnsplashDownloadResponseError)(nil), "anytype.Rpc.Unsplash.Download.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((*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((*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((*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((*RpcBlockCreateWidget)(nil), "anytype.Rpc.Block.CreateWidget")
	proto.RegisterType((*RpcBlockCreateWidgetRequest)(nil), "anytype.Rpc.Block.CreateWidget.Request")
	proto.RegisterType((*RpcBlockCreateWidgetResponse)(nil), "anytype.Rpc.Block.CreateWidget.Response")
	proto.RegisterType((*RpcBlockCreateWidgetResponseError)(nil), "anytype.Rpc.Block.CreateWidget.Response.Error")
	proto.RegisterType((*RpcBlockListDelete)(nil), "anytype.Rpc.Block.ListDelete")
	proto.RegisterType((*RpcBlockListDeleteRequest)(nil), "anytype.Rpc.Block.ListDelete.Request")
	proto.RegisterType((*RpcBlockListDeleteResponse)(nil), "anytype.Rpc.Block.ListDelete.Response")
	proto.RegisterType((*RpcBlockListDeleteResponseError)(nil), "anytype.Rpc.Block.ListDelete.Response.Error")
	proto.RegisterType((*RpcBlockSetFields)(nil), "anytype.Rpc.Block.SetFields")
	proto.RegisterType((*RpcBlockSetFieldsRequest)(nil), "anytype.Rpc.Block.SetFields.Request")
	proto.RegisterType((*RpcBlockSetFieldsResponse)(nil), "anytype.Rpc.Block.SetFields.Response")
	proto.RegisterType((*RpcBlockSetFieldsResponseError)(nil), "anytype.Rpc.Block.SetFields.Response.Error")
	proto.RegisterType((*RpcBlockListSetAlign)(nil), "anytype.Rpc.Block.ListSetAlign")
	proto.RegisterType((*RpcBlockListSetAlignRequest)(nil), "anytype.Rpc.Block.ListSetAlign.Request")
	proto.RegisterType((*RpcBlockListSetAlignResponse)(nil), "anytype.Rpc.Block.ListSetAlign.Response")
	proto.RegisterType((*RpcBlockListSetAlignResponseError)(nil), "anytype.Rpc.Block.ListSetAlign.Response.Error")
	proto.RegisterType((*RpcBlockListSetVerticalAlign)(nil), "anytype.Rpc.Block.ListSetVerticalAlign")
	proto.RegisterType((*RpcBlockListSetVerticalAlignRequest)(nil), "anytype.Rpc.Block.ListSetVerticalAlign.Request")
	proto.RegisterType((*RpcBlockListSetVerticalAlignResponse)(nil), "anytype.Rpc.Block.ListSetVerticalAlign.Response")
	proto.RegisterType((*RpcBlockListSetVerticalAlignResponseError)(nil), "anytype.Rpc.Block.ListSetVerticalAlign.Response.Error")
	proto.RegisterType((*RpcBlockListSetFields)(nil), "anytype.Rpc.Block.ListSetFields")
	proto.RegisterType((*RpcBlockListSetFieldsRequest)(nil), "anytype.Rpc.Block.ListSetFields.Request")
	proto.RegisterType((*RpcBlockListSetFieldsRequestBlockField)(nil), "anytype.Rpc.Block.ListSetFields.Request.BlockField")
	proto.RegisterType((*RpcBlockListSetFieldsResponse)(nil), "anytype.Rpc.Block.ListSetFields.Response")
	proto.RegisterType((*RpcBlockListSetFieldsResponseError)(nil), "anytype.Rpc.Block.ListSetFields.Response.Error")
	proto.RegisterType((*RpcBlockListDuplicate)(nil), "anytype.Rpc.Block.ListDuplicate")
	proto.RegisterType((*RpcBlockListDuplicateRequest)(nil), "anytype.Rpc.Block.ListDuplicate.Request")
	proto.RegisterType((*RpcBlockListDuplicateResponse)(nil), "anytype.Rpc.Block.ListDuplicate.Response")
	proto.RegisterType((*RpcBlockListDuplicateResponseError)(nil), "anytype.Rpc.Block.ListDuplicate.Response.Error")
	proto.RegisterType((*RpcBlockListUpdate)(nil), "anytype.Rpc.Block.ListUpdate")
	proto.RegisterType((*RpcBlockListUpdateRequest)(nil), "anytype.Rpc.Block.ListUpdate.Request")
	proto.RegisterType((*RpcBlockListUpdateRequestText)(nil), "anytype.Rpc.Block.ListUpdate.Request.Text")
	proto.RegisterType((*RpcBlockListConvertToObjects)(nil), "anytype.Rpc.Block.ListConvertToObjects")
	proto.RegisterType((*RpcBlockListConvertToObjectsRequest)(nil), "anytype.Rpc.Block.ListConvertToObjects.Request")
	proto.RegisterType((*RpcBlockListConvertToObjectsResponse)(nil), "anytype.Rpc.Block.ListConvertToObjects.Response")
	proto.RegisterType((*RpcBlockListConvertToObjectsResponseError)(nil), "anytype.Rpc.Block.ListConvertToObjects.Response.Error")
	proto.RegisterType((*RpcBlockListMoveToExistingObject)(nil), "anytype.Rpc.Block.ListMoveToExistingObject")
	proto.RegisterType((*RpcBlockListMoveToExistingObjectRequest)(nil), "anytype.Rpc.Block.ListMoveToExistingObject.Request")
	proto.RegisterType((*RpcBlockListMoveToExistingObjectResponse)(nil), "anytype.Rpc.Block.ListMoveToExistingObject.Response")
	proto.RegisterType((*RpcBlockListMoveToExistingObjectResponseError)(nil), "anytype.Rpc.Block.ListMoveToExistingObject.Response.Error")
	proto.RegisterType((*RpcBlockListMoveToNewObject)(nil), "anytype.Rpc.Block.ListMoveToNewObject")
	proto.RegisterType((*RpcBlockListMoveToNewObjectRequest)(nil), "anytype.Rpc.Block.ListMoveToNewObject.Request")
	proto.RegisterType((*RpcBlockListMoveToNewObjectResponse)(nil), "anytype.Rpc.Block.ListMoveToNewObject.Response")
	proto.RegisterType((*RpcBlockListMoveToNewObjectResponseError)(nil), "anytype.Rpc.Block.ListMoveToNewObject.Response.Error")
	proto.RegisterType((*RpcBlockListTurnInto)(nil), "anytype.Rpc.Block.ListTurnInto")
	proto.RegisterType((*RpcBlockListTurnIntoRequest)(nil), "anytype.Rpc.Block.ListTurnInto.Request")
	proto.RegisterType((*RpcBlockListTurnIntoResponse)(nil), "anytype.Rpc.Block.ListTurnInto.Response")
	proto.RegisterType((*RpcBlockListTurnIntoResponseError)(nil), "anytype.Rpc.Block.ListTurnInto.Response.Error")
	proto.RegisterType((*RpcBlockListSetBackgroundColor)(nil), "anytype.Rpc.Block.ListSetBackgroundColor")
	proto.RegisterType((*RpcBlockListSetBackgroundColorRequest)(nil), "anytype.Rpc.Block.ListSetBackgroundColor.Request")
	proto.RegisterType((*RpcBlockListSetBackgroundColorResponse)(nil), "anytype.Rpc.Block.ListSetBackgroundColor.Response")
	proto.RegisterType((*RpcBlockListSetBackgroundColorResponseError)(nil), "anytype.Rpc.Block.ListSetBackgroundColor.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((*RpcBlockLatex)(nil), "anytype.Rpc.BlockLatex")
	proto.RegisterType((*RpcBlockLatexSetText)(nil), "anytype.Rpc.BlockLatex.SetText")
	proto.RegisterType((*RpcBlockLatexSetTextRequest)(nil), "anytype.Rpc.BlockLatex.SetText.Request")
	proto.RegisterType((*RpcBlockLatexSetTextResponse)(nil), "anytype.Rpc.BlockLatex.SetText.Response")
	proto.RegisterType((*RpcBlockLatexSetTextResponseError)(nil), "anytype.Rpc.BlockLatex.SetText.Response.Error")
	proto.RegisterType((*RpcBlockText)(nil), "anytype.Rpc.BlockText")
	proto.RegisterType((*RpcBlockTextSetText)(nil), "anytype.Rpc.BlockText.SetText")
	proto.RegisterType((*RpcBlockTextSetTextRequest)(nil), "anytype.Rpc.BlockText.SetText.Request")
	proto.RegisterType((*RpcBlockTextSetTextResponse)(nil), "anytype.Rpc.BlockText.SetText.Response")
	proto.RegisterType((*RpcBlockTextSetTextResponseError)(nil), "anytype.Rpc.BlockText.SetText.Response.Error")
	proto.RegisterType((*RpcBlockTextSetColor)(nil), "anytype.Rpc.BlockText.SetColor")
	proto.RegisterType((*RpcBlockTextSetColorRequest)(nil), "anytype.Rpc.BlockText.SetColor.Request")
	proto.RegisterType((*RpcBlockTextSetColorResponse)(nil), "anytype.Rpc.BlockText.SetColor.Response")
	proto.RegisterType((*RpcBlockTextSetColorResponseError)(nil), "anytype.Rpc.BlockText.SetColor.Response.Error")
	proto.RegisterType((*RpcBlockTextSetMarks)(nil), "anytype.Rpc.BlockText.SetMarks")
	proto.RegisterType((*RpcBlockTextSetMarksGet)(nil), "anytype.Rpc.BlockText.SetMarks.Get")
	proto.RegisterType((*RpcBlockTextSetMarksGetRequest)(nil), "anytype.Rpc.BlockText.SetMarks.Get.Request")
	proto.RegisterType((*RpcBlockTextSetMarksGetResponse)(nil), "anytype.Rpc.BlockText.SetMarks.Get.Response")
	proto.RegisterType((*RpcBlockTextSetMarksGetResponseError)(nil), "anytype.Rpc.BlockText.SetMarks.Get.Response.Error")
	proto.RegisterType((*RpcBlockTextSetStyle)(nil), "anytype.Rpc.BlockText.SetStyle")
	proto.RegisterType((*RpcBlockTextSetStyleRequest)(nil), "anytype.Rpc.BlockText.SetStyle.Request")
	proto.RegisterType((*RpcBlockTextSetStyleResponse)(nil), "anytype.Rpc.BlockText.SetStyle.Response")
	proto.RegisterType((*RpcBlockTextSetStyleResponseError)(nil), "anytype.Rpc.BlockText.SetStyle.Response.Error")
	proto.RegisterType((*RpcBlockTextSetChecked)(nil), "anytype.Rpc.BlockText.SetChecked")
	proto.RegisterType((*RpcBlockTextSetCheckedRequest)(nil), "anytype.Rpc.BlockText.SetChecked.Request")
	proto.RegisterType((*RpcBlockTextSetCheckedResponse)(nil), "anytype.Rpc.BlockText.SetChecked.Response")
	proto.RegisterType((*RpcBlockTextSetCheckedResponseError)(nil), "anytype.Rpc.BlockText.SetChecked.Response.Error")
	proto.RegisterType((*RpcBlockTextSetIcon)(nil), "anytype.Rpc.BlockText.SetIcon")
	proto.RegisterType((*RpcBlockTextSetIconRequest)(nil), "anytype.Rpc.BlockText.SetIcon.Request")
	proto.RegisterType((*RpcBlockTextSetIconResponse)(nil), "anytype.Rpc.BlockText.SetIcon.Response")
	proto.RegisterType((*RpcBlockTextSetIconResponseError)(nil), "anytype.Rpc.BlockText.SetIcon.Response.Error")
	proto.RegisterType((*RpcBlockTextListSetStyle)(nil), "anytype.Rpc.BlockText.ListSetStyle")
	proto.RegisterType((*RpcBlockTextListSetStyleRequest)(nil), "anytype.Rpc.BlockText.ListSetStyle.Request")
	proto.RegisterType((*RpcBlockTextListSetStyleResponse)(nil), "anytype.Rpc.BlockText.ListSetStyle.Response")
	proto.RegisterType((*RpcBlockTextListSetStyleResponseError)(nil), "anytype.Rpc.BlockText.ListSetStyle.Response.Error")
	proto.RegisterType((*RpcBlockTextListSetColor)(nil), "anytype.Rpc.BlockText.ListSetColor")
	proto.RegisterType((*RpcBlockTextListSetColorRequest)(nil), "anytype.Rpc.BlockText.ListSetColor.Request")
	proto.RegisterType((*RpcBlockTextListSetColorResponse)(nil), "anytype.Rpc.BlockText.ListSetColor.Response")
	proto.RegisterType((*RpcBlockTextListSetColorResponseError)(nil), "anytype.Rpc.BlockText.ListSetColor.Response.Error")
	proto.RegisterType((*RpcBlockTextListSetMark)(nil), "anytype.Rpc.BlockText.ListSetMark")
	proto.RegisterType((*RpcBlockTextListSetMarkRequest)(nil), "anytype.Rpc.BlockText.ListSetMark.Request")
	proto.RegisterType((*RpcBlockTextListSetMarkResponse)(nil), "anytype.Rpc.BlockText.ListSetMark.Response")
	proto.RegisterType((*RpcBlockTextListSetMarkResponseError)(nil), "anytype.Rpc.BlockText.ListSetMark.Response.Error")
	proto.RegisterType((*RpcBlockTextListClearStyle)(nil), "anytype.Rpc.BlockText.ListClearStyle")
	proto.RegisterType((*RpcBlockTextListClearStyleRequest)(nil), "anytype.Rpc.BlockText.ListClearStyle.Request")
	proto.RegisterType((*RpcBlockTextListClearStyleResponse)(nil), "anytype.Rpc.BlockText.ListClearStyle.Response")
	proto.RegisterType((*RpcBlockTextListClearStyleResponseError)(nil), "anytype.Rpc.BlockText.ListClearStyle.Response.Error")
	proto.RegisterType((*RpcBlockTextListClearContent)(nil), "anytype.Rpc.BlockText.ListClearContent")
	proto.RegisterType((*RpcBlockTextListClearContentRequest)(nil), "anytype.Rpc.BlockText.ListClearContent.Request")
	proto.RegisterType((*RpcBlockTextListClearContentResponse)(nil), "anytype.Rpc.BlockText.ListClearContent.Response")
	proto.RegisterType((*RpcBlockTextListClearContentResponseError)(nil), "anytype.Rpc.BlockText.ListClearContent.Response.Error")
	proto.RegisterType((*RpcBlockTable)(nil), "anytype.Rpc.BlockTable")
	proto.RegisterType((*RpcBlockTableCreate)(nil), "anytype.Rpc.BlockTable.Create")
	proto.RegisterType((*RpcBlockTableCreateRequest)(nil), "anytype.Rpc.BlockTable.Create.Request")
	proto.RegisterType((*RpcBlockTableCreateResponse)(nil), "anytype.Rpc.BlockTable.Create.Response")
	proto.RegisterType((*RpcBlockTableCreateResponseError)(nil), "anytype.Rpc.BlockTable.Create.Response.Error")
	proto.RegisterType((*RpcBlockTableRowCreate)(nil), "anytype.Rpc.BlockTable.RowCreate")
	proto.RegisterType((*RpcBlockTableRowCreateRequest)(nil), "anytype.Rpc.BlockTable.RowCreate.Request")
	proto.RegisterType((*RpcBlockTableRowCreateResponse)(nil), "anytype.Rpc.BlockTable.RowCreate.Response")
	proto.RegisterType((*RpcBlockTableRowCreateResponseError)(nil), "anytype.Rpc.BlockTable.RowCreate.Response.Error")
	proto.RegisterType((*RpcBlockTableRowSetHeader)(nil), "anytype.Rpc.BlockTable.RowSetHeader")
	proto.RegisterType((*RpcBlockTableRowSetHeaderRequest)(nil), "anytype.Rpc.BlockTable.RowSetHeader.Request")
	proto.RegisterType((*RpcBlockTableRowSetHeaderResponse)(nil), "anytype.Rpc.BlockTable.RowSetHeader.Response")
	proto.RegisterType((*RpcBlockTableRowSetHeaderResponseError)(nil), "anytype.Rpc.BlockTable.RowSetHeader.Response.Error")
	proto.RegisterType((*RpcBlockTableRowListFill)(nil), "anytype.Rpc.BlockTable.RowListFill")
	proto.RegisterType((*RpcBlockTableRowListFillRequest)(nil), "anytype.Rpc.BlockTable.RowListFill.Request")
	proto.RegisterType((*RpcBlockTableRowListFillResponse)(nil), "anytype.Rpc.BlockTable.RowListFill.Response")
	proto.RegisterType((*RpcBlockTableRowListFillResponseError)(nil), "anytype.Rpc.BlockTable.RowListFill.Response.Error")
	proto.RegisterType((*RpcBlockTableRowListClean)(nil), "anytype.Rpc.BlockTable.RowListClean")
	proto.RegisterType((*RpcBlockTableRowListCleanRequest)(nil), "anytype.Rpc.BlockTable.RowListClean.Request")
	proto.RegisterType((*RpcBlockTableRowListCleanResponse)(nil), "anytype.Rpc.BlockTable.RowListClean.Response")
	proto.RegisterType((*RpcBlockTableRowListCleanResponseError)(nil), "anytype.Rpc.BlockTable.RowListClean.Response.Error")
	proto.RegisterType((*RpcBlockTableColumnListFill)(nil), "anytype.Rpc.BlockTable.ColumnListFill")
	proto.RegisterType((*RpcBlockTableColumnListFillRequest)(nil), "anytype.Rpc.BlockTable.ColumnListFill.Request")
	proto.RegisterType((*RpcBlockTableColumnListFillResponse)(nil), "anytype.Rpc.BlockTable.ColumnListFill.Response")
	proto.RegisterType((*RpcBlockTableColumnListFillResponseError)(nil), "anytype.Rpc.BlockTable.ColumnListFill.Response.Error")
	proto.RegisterType((*RpcBlockTableColumnCreate)(nil), "anytype.Rpc.BlockTable.ColumnCreate")
	proto.RegisterType((*RpcBlockTableColumnCreateRequest)(nil), "anytype.Rpc.BlockTable.ColumnCreate.Request")
	proto.RegisterType((*RpcBlockTableColumnCreateResponse)(nil), "anytype.Rpc.BlockTable.ColumnCreate.Response")
	proto.RegisterType((*RpcBlockTableColumnCreateResponseError)(nil), "anytype.Rpc.BlockTable.ColumnCreate.Response.Error")
	proto.RegisterType((*RpcBlockTableRowDelete)(nil), "anytype.Rpc.BlockTable.RowDelete")
	proto.RegisterType((*RpcBlockTableRowDeleteRequest)(nil), "anytype.Rpc.BlockTable.RowDelete.Request")
	proto.RegisterType((*RpcBlockTableRowDeleteResponse)(nil), "anytype.Rpc.BlockTable.RowDelete.Response")
	proto.RegisterType((*RpcBlockTableRowDeleteResponseError)(nil), "anytype.Rpc.BlockTable.RowDelete.Response.Error")
	proto.RegisterType((*RpcBlockTableColumnDelete)(nil), "anytype.Rpc.BlockTable.ColumnDelete")
	proto.RegisterType((*RpcBlockTableColumnDeleteRequest)(nil), "anytype.Rpc.BlockTable.ColumnDelete.Request")
	proto.RegisterType((*RpcBlockTableColumnDeleteResponse)(nil), "anytype.Rpc.BlockTable.ColumnDelete.Response")
	proto.RegisterType((*RpcBlockTableColumnDeleteResponseError)(nil), "anytype.Rpc.BlockTable.ColumnDelete.Response.Error")
	proto.RegisterType((*RpcBlockTableColumnMove)(nil), "anytype.Rpc.BlockTable.ColumnMove")
	proto.RegisterType((*RpcBlockTableColumnMoveRequest)(nil), "anytype.Rpc.BlockTable.ColumnMove.Request")
	proto.RegisterType((*RpcBlockTableColumnMoveResponse)(nil), "anytype.Rpc.BlockTable.ColumnMove.Response")
	proto.RegisterType((*RpcBlockTableColumnMoveResponseError)(nil), "anytype.Rpc.BlockTable.ColumnMove.Response.Error")
	proto.RegisterType((*RpcBlockTableRowDuplicate)(nil), "anytype.Rpc.BlockTable.RowDuplicate")
	proto.RegisterType((*RpcBlockTableRowDuplicateRequest)(nil), "anytype.Rpc.BlockTable.RowDuplicate.Request")
	proto.RegisterType((*RpcBlockTableRowDuplicateResponse)(nil), "anytype.Rpc.BlockTable.RowDuplicate.Response")
	proto.RegisterType((*RpcBlockTableRowDuplicateResponseError)(nil), "anytype.Rpc.BlockTable.RowDuplicate.Response.Error")
	proto.RegisterType((*RpcBlockTableColumnDuplicate)(nil), "anytype.Rpc.BlockTable.ColumnDuplicate")
	proto.RegisterType((*RpcBlockTableColumnDuplicateRequest)(nil), "anytype.Rpc.BlockTable.ColumnDuplicate.Request")
	proto.RegisterType((*RpcBlockTableColumnDuplicateResponse)(nil), "anytype.Rpc.BlockTable.ColumnDuplicate.Response")
	proto.RegisterType((*RpcBlockTableColumnDuplicateResponseError)(nil), "anytype.Rpc.BlockTable.ColumnDuplicate.Response.Error")
	proto.RegisterType((*RpcBlockTableExpand)(nil), "anytype.Rpc.BlockTable.Expand")
	proto.RegisterType((*RpcBlockTableExpandRequest)(nil), "anytype.Rpc.BlockTable.Expand.Request")
	proto.RegisterType((*RpcBlockTableExpandResponse)(nil), "anytype.Rpc.BlockTable.Expand.Response")
	proto.RegisterType((*RpcBlockTableExpandResponseError)(nil), "anytype.Rpc.BlockTable.Expand.Response.Error")
	proto.RegisterType((*RpcBlockTableSort)(nil), "anytype.Rpc.BlockTable.Sort")
	proto.RegisterType((*RpcBlockTableSortRequest)(nil), "anytype.Rpc.BlockTable.Sort.Request")
	proto.RegisterType((*RpcBlockTableSortResponse)(nil), "anytype.Rpc.BlockTable.Sort.Response")
	proto.RegisterType((*RpcBlockTableSortResponseError)(nil), "anytype.Rpc.BlockTable.Sort.Response.Error")
	proto.RegisterType((*RpcBlockFile)(nil), "anytype.Rpc.BlockFile")
	proto.RegisterType((*RpcBlockFileSetName)(nil), "anytype.Rpc.BlockFile.SetName")
	proto.RegisterType((*RpcBlockFileSetNameRequest)(nil), "anytype.Rpc.BlockFile.SetName.Request")
	proto.RegisterType((*RpcBlockFileSetNameResponse)(nil), "anytype.Rpc.BlockFile.SetName.Response")
	proto.RegisterType((*RpcBlockFileSetNameResponseError)(nil), "anytype.Rpc.BlockFile.SetName.Response.Error")
	proto.RegisterType((*RpcBlockFileCreateAndUpload)(nil), "anytype.Rpc.BlockFile.CreateAndUpload")
	proto.RegisterType((*RpcBlockFileCreateAndUploadRequest)(nil), "anytype.Rpc.BlockFile.CreateAndUpload.Request")
	proto.RegisterType((*RpcBlockFileCreateAndUploadResponse)(nil), "anytype.Rpc.BlockFile.CreateAndUpload.Response")
	proto.RegisterType((*RpcBlockFileCreateAndUploadResponseError)(nil), "anytype.Rpc.BlockFile.CreateAndUpload.Response.Error")
	proto.RegisterType((*RpcBlockFileListSetStyle)(nil), "anytype.Rpc.BlockFile.ListSetStyle")
	proto.RegisterType((*RpcBlockFileListSetStyleRequest)(nil), "anytype.Rpc.BlockFile.ListSetStyle.Request")
	proto.RegisterType((*RpcBlockFileListSetStyleResponse)(nil), "anytype.Rpc.BlockFile.ListSetStyle.Response")
	proto.RegisterType((*RpcBlockFileListSetStyleResponseError)(nil), "anytype.Rpc.BlockFile.ListSetStyle.Response.Error")
	proto.RegisterType((*RpcBlockImage)(nil), "anytype.Rpc.BlockImage")
	proto.RegisterType((*RpcBlockImageSetName)(nil), "anytype.Rpc.BlockImage.SetName")
	proto.RegisterType((*RpcBlockImageSetNameRequest)(nil), "anytype.Rpc.BlockImage.SetName.Request")
	proto.RegisterType((*RpcBlockImageSetNameResponse)(nil), "anytype.Rpc.BlockImage.SetName.Response")
	proto.RegisterType((*RpcBlockImageSetNameResponseError)(nil), "anytype.Rpc.BlockImage.SetName.Response.Error")
	proto.RegisterType((*RpcBlockImageSetWidth)(nil), "anytype.Rpc.BlockImage.SetWidth")
	proto.RegisterType((*RpcBlockImageSetWidthRequest)(nil), "anytype.Rpc.BlockImage.SetWidth.Request")
	proto.RegisterType((*RpcBlockImageSetWidthResponse)(nil), "anytype.Rpc.BlockImage.SetWidth.Response")
	proto.RegisterType((*RpcBlockImageSetWidthResponseError)(nil), "anytype.Rpc.BlockImage.SetWidth.Response.Error")
	proto.RegisterType((*RpcBlockVideo)(nil), "anytype.Rpc.BlockVideo")
	proto.RegisterType((*RpcBlockVideoSetName)(nil), "anytype.Rpc.BlockVideo.SetName")
	proto.RegisterType((*RpcBlockVideoSetNameRequest)(nil), "anytype.Rpc.BlockVideo.SetName.Request")
	proto.RegisterType((*RpcBlockVideoSetNameResponse)(nil), "anytype.Rpc.BlockVideo.SetName.Response")
	proto.RegisterType((*RpcBlockVideoSetNameResponseError)(nil), "anytype.Rpc.BlockVideo.SetName.Response.Error")
	proto.RegisterType((*RpcBlockVideoSetWidth)(nil), "anytype.Rpc.BlockVideo.SetWidth")
	proto.RegisterType((*RpcBlockVideoSetWidthRequest)(nil), "anytype.Rpc.BlockVideo.SetWidth.Request")
	proto.RegisterType((*RpcBlockVideoSetWidthResponse)(nil), "anytype.Rpc.BlockVideo.SetWidth.Response")
	proto.RegisterType((*RpcBlockVideoSetWidthResponseError)(nil), "anytype.Rpc.BlockVideo.SetWidth.Response.Error")
	proto.RegisterType((*RpcBlockLink)(nil), "anytype.Rpc.BlockLink")
	proto.RegisterType((*RpcBlockLinkCreateWithObject)(nil), "anytype.Rpc.BlockLink.CreateWithObject")
	proto.RegisterType((*RpcBlockLinkCreateWithObjectRequest)(nil), "anytype.Rpc.BlockLink.CreateWithObject.Request")
	proto.RegisterType((*RpcBlockLinkCreateWithObjectResponse)(nil), "anytype.Rpc.BlockLink.CreateWithObject.Response")
	proto.RegisterType((*RpcBlockLinkCreateWithObjectResponseError)(nil), "anytype.Rpc.BlockLink.CreateWithObject.Response.Error")
	proto.RegisterType((*RpcBlockLinkListSetAppearance)(nil), "anytype.Rpc.BlockLink.ListSetAppearance")
	proto.RegisterType((*RpcBlockLinkListSetAppearanceRequest)(nil), "anytype.Rpc.BlockLink.ListSetAppearance.Request")
	proto.RegisterType((*RpcBlockLinkListSetAppearanceResponse)(nil), "anytype.Rpc.BlockLink.ListSetAppearance.Response")
	proto.RegisterType((*RpcBlockLinkListSetAppearanceResponseError)(nil), "anytype.Rpc.BlockLink.ListSetAppearance.Response.Error")
	proto.RegisterType((*RpcBlockRelation)(nil), "anytype.Rpc.BlockRelation")
	proto.RegisterType((*RpcBlockRelationSetKey)(nil), "anytype.Rpc.BlockRelation.SetKey")
	proto.RegisterType((*RpcBlockRelationSetKeyRequest)(nil), "anytype.Rpc.BlockRelation.SetKey.Request")
	proto.RegisterType((*RpcBlockRelationSetKeyResponse)(nil), "anytype.Rpc.BlockRelation.SetKey.Response")
	proto.RegisterType((*RpcBlockRelationSetKeyResponseError)(nil), "anytype.Rpc.BlockRelation.SetKey.Response.Error")
	proto.RegisterType((*RpcBlockRelationAdd)(nil), "anytype.Rpc.BlockRelation.Add")
	proto.RegisterType((*RpcBlockRelationAddRequest)(nil), "anytype.Rpc.BlockRelation.Add.Request")
	proto.RegisterType((*RpcBlockRelationAddResponse)(nil), "anytype.Rpc.BlockRelation.Add.Response")
	proto.RegisterType((*RpcBlockRelationAddResponseError)(nil), "anytype.Rpc.BlockRelation.Add.Response.Error")
	proto.RegisterType((*RpcBlockBookmark)(nil), "anytype.Rpc.BlockBookmark")
	proto.RegisterType((*RpcBlockBookmarkFetch)(nil), "anytype.Rpc.BlockBookmark.Fetch")
	proto.RegisterType((*RpcBlockBookmarkFetchRequest)(nil), "anytype.Rpc.BlockBookmark.Fetch.Request")
	proto.RegisterType((*RpcBlockBookmarkFetchResponse)(nil), "anytype.Rpc.BlockBookmark.Fetch.Response")
	proto.RegisterType((*RpcBlockBookmarkFetchResponseError)(nil), "anytype.Rpc.BlockBookmark.Fetch.Response.Error")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetch)(nil), "anytype.Rpc.BlockBookmark.CreateAndFetch")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetchRequest)(nil), "anytype.Rpc.BlockBookmark.CreateAndFetch.Request")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetchResponse)(nil), "anytype.Rpc.BlockBookmark.CreateAndFetch.Response")
	proto.RegisterType((*RpcBlockBookmarkCreateAndFetchResponseError)(nil), "anytype.Rpc.BlockBookmark.CreateAndFetch.Response.Error")
	proto.RegisterType((*RpcBlockDiv)(nil), "anytype.Rpc.BlockDiv")
	proto.RegisterType((*RpcBlockDivListSetStyle)(nil), "anytype.Rpc.BlockDiv.ListSetStyle")
	proto.RegisterType((*RpcBlockDivListSetStyleRequest)(nil), "anytype.Rpc.BlockDiv.ListSetStyle.Request")
	proto.RegisterType((*RpcBlockDivListSetStyleResponse)(nil), "anytype.Rpc.BlockDiv.ListSetStyle.Response")
	proto.RegisterType((*RpcBlockDivListSetStyleResponseError)(nil), "anytype.Rpc.BlockDiv.ListSetStyle.Response.Error")
	proto.RegisterType((*RpcBlockDataview)(nil), "anytype.Rpc.BlockDataview")
	proto.RegisterType((*RpcBlockDataviewView)(nil), "anytype.Rpc.BlockDataview.View")
	proto.RegisterType((*RpcBlockDataviewViewCreate)(nil), "anytype.Rpc.BlockDataview.View.Create")
	proto.RegisterType((*RpcBlockDataviewViewCreateRequest)(nil), "anytype.Rpc.BlockDataview.View.Create.Request")
	proto.RegisterType((*RpcBlockDataviewViewCreateResponse)(nil), "anytype.Rpc.BlockDataview.View.Create.Response")
	proto.RegisterType((*RpcBlockDataviewViewCreateResponseError)(nil), "anytype.Rpc.BlockDataview.View.Create.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewUpdate)(nil), "anytype.Rpc.BlockDataview.View.Update")
	proto.RegisterType((*RpcBlockDataviewViewUpdateRequest)(nil), "anytype.Rpc.BlockDataview.View.Update.Request")
	proto.RegisterType((*RpcBlockDataviewViewUpdateResponse)(nil), "anytype.Rpc.BlockDataview.View.Update.Response")
	proto.RegisterType((*RpcBlockDataviewViewUpdateResponseError)(nil), "anytype.Rpc.BlockDataview.View.Update.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewDelete)(nil), "anytype.Rpc.BlockDataview.View.Delete")
	proto.RegisterType((*RpcBlockDataviewViewDeleteRequest)(nil), "anytype.Rpc.BlockDataview.View.Delete.Request")
	proto.RegisterType((*RpcBlockDataviewViewDeleteResponse)(nil), "anytype.Rpc.BlockDataview.View.Delete.Response")
	proto.RegisterType((*RpcBlockDataviewViewDeleteResponseError)(nil), "anytype.Rpc.BlockDataview.View.Delete.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewSetPosition)(nil), "anytype.Rpc.BlockDataview.View.SetPosition")
	proto.RegisterType((*RpcBlockDataviewViewSetPositionRequest)(nil), "anytype.Rpc.BlockDataview.View.SetPosition.Request")
	proto.RegisterType((*RpcBlockDataviewViewSetPositionResponse)(nil), "anytype.Rpc.BlockDataview.View.SetPosition.Response")
	proto.RegisterType((*RpcBlockDataviewViewSetPositionResponseError)(nil), "anytype.Rpc.BlockDataview.View.SetPosition.Response.Error")
	proto.RegisterType((*RpcBlockDataviewViewSetActive)(nil), "anytype.Rpc.BlockDataview.View.SetActive")
	proto.RegisterType((*RpcBlockDataviewViewSetActiveRequest)(nil), "anytype.Rpc.BlockDataview.View.SetActive.Request")
	proto.RegisterType((*RpcBlockDataviewViewSetActiveResponse)(nil), "anytype.Rpc.BlockDataview.View.SetActive.Response")
	proto.RegisterType((*RpcBlockDataviewViewSetActiveResponseError)(nil), "anytype.Rpc.BlockDataview.View.SetActive.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelation)(nil), "anytype.Rpc.BlockDataview.Relation")
	proto.RegisterType((*RpcBlockDataviewRelationAdd)(nil), "anytype.Rpc.BlockDataview.Relation.Add")
	proto.RegisterType((*RpcBlockDataviewRelationAddRequest)(nil), "anytype.Rpc.BlockDataview.Relation.Add.Request")
	proto.RegisterType((*RpcBlockDataviewRelationAddResponse)(nil), "anytype.Rpc.BlockDataview.Relation.Add.Response")
	proto.RegisterType((*RpcBlockDataviewRelationAddResponseError)(nil), "anytype.Rpc.BlockDataview.Relation.Add.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelationDelete)(nil), "anytype.Rpc.BlockDataview.Relation.Delete")
	proto.RegisterType((*RpcBlockDataviewRelationDeleteRequest)(nil), "anytype.Rpc.BlockDataview.Relation.Delete.Request")
	proto.RegisterType((*RpcBlockDataviewRelationDeleteResponse)(nil), "anytype.Rpc.BlockDataview.Relation.Delete.Response")
	proto.RegisterType((*RpcBlockDataviewRelationDeleteResponseError)(nil), "anytype.Rpc.BlockDataview.Relation.Delete.Response.Error")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailable)(nil), "anytype.Rpc.BlockDataview.Relation.ListAvailable")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailableRequest)(nil), "anytype.Rpc.BlockDataview.Relation.ListAvailable.Request")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailableResponse)(nil), "anytype.Rpc.BlockDataview.Relation.ListAvailable.Response")
	proto.RegisterType((*RpcBlockDataviewRelationListAvailableResponseError)(nil), "anytype.Rpc.BlockDataview.Relation.ListAvailable.Response.Error")
	proto.RegisterType((*RpcBlockDataviewSetSource)(nil), "anytype.Rpc.BlockDataview.SetSource")
	proto.RegisterType((*RpcBlockDataviewSetSourceRequest)(nil), "anytype.Rpc.BlockDataview.SetSource.Request")
	proto.RegisterType((*RpcBlockDataviewSetSourceResponse)(nil), "anytype.Rpc.BlockDataview.SetSource.Response")
	proto.RegisterType((*RpcBlockDataviewSetSourceResponseError)(nil), "anytype.Rpc.BlockDataview.SetSource.Response.Error")
	proto.RegisterType((*RpcBlockDataviewGroupOrder)(nil), "anytype.Rpc.BlockDataview.GroupOrder")
	proto.RegisterType((*RpcBlockDataviewGroupOrderUpdate)(nil), "anytype.Rpc.BlockDataview.GroupOrder.Update")
	proto.RegisterType((*RpcBlockDataviewGroupOrderUpdateRequest)(nil), "anytype.Rpc.BlockDataview.GroupOrder.Update.Request")
	proto.RegisterType((*RpcBlockDataviewGroupOrderUpdateResponse)(nil), "anytype.Rpc.BlockDataview.GroupOrder.Update.Response")
	proto.RegisterType((*RpcBlockDataviewGroupOrderUpdateResponseError)(nil), "anytype.Rpc.BlockDataview.GroupOrder.Update.Response.Error")
	proto.RegisterType((*RpcBlockDataviewObjectOrder)(nil), "anytype.Rpc.BlockDataview.ObjectOrder")
	proto.RegisterType((*RpcBlockDataviewObjectOrderUpdate)(nil), "anytype.Rpc.BlockDataview.ObjectOrder.Update")
	proto.RegisterType((*RpcBlockDataviewObjectOrderUpdateRequest)(nil), "anytype.Rpc.BlockDataview.ObjectOrder.Update.Request")
	proto.RegisterType((*RpcBlockDataviewObjectOrderUpdateResponse)(nil), "anytype.Rpc.BlockDataview.ObjectOrder.Update.Response")
	proto.RegisterType((*RpcBlockDataviewObjectOrderUpdateResponseError)(nil), "anytype.Rpc.BlockDataview.ObjectOrder.Update.Response.Error")
	proto.RegisterType((*RpcBlockDataviewCreateBookmark)(nil), "anytype.Rpc.BlockDataview.CreateBookmark")
	proto.RegisterType((*RpcBlockDataviewCreateBookmarkRequest)(nil), "anytype.Rpc.BlockDataview.CreateBookmark.Request")
	proto.RegisterType((*RpcBlockDataviewCreateBookmarkResponse)(nil), "anytype.Rpc.BlockDataview.CreateBookmark.Response")
	proto.RegisterType((*RpcBlockDataviewCreateBookmarkResponseError)(nil), "anytype.Rpc.BlockDataview.CreateBookmark.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((*RpcDebugExportLocalstore)(nil), "anytype.Rpc.Debug.ExportLocalstore")
	proto.RegisterType((*RpcDebugExportLocalstoreRequest)(nil), "anytype.Rpc.Debug.ExportLocalstore.Request")
	proto.RegisterType((*RpcDebugExportLocalstoreResponse)(nil), "anytype.Rpc.Debug.ExportLocalstore.Response")
	proto.RegisterType((*RpcDebugExportLocalstoreResponseError)(nil), "anytype.Rpc.Debug.ExportLocalstore.Response.Error")
	proto.RegisterType((*RpcDebugPing)(nil), "anytype.Rpc.Debug.Ping")
	proto.RegisterType((*RpcDebugPingRequest)(nil), "anytype.Rpc.Debug.Ping.Request")
	proto.RegisterType((*RpcDebugPingResponse)(nil), "anytype.Rpc.Debug.Ping.Response")
	proto.RegisterType((*RpcDebugPingResponseError)(nil), "anytype.Rpc.Debug.Ping.Response.Error")
	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((*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((*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((*RpcGenericErrorResponse)(nil), "anytype.Rpc.GenericErrorResponse")
	proto.RegisterType((*RpcGenericErrorResponseError)(nil), "anytype.Rpc.GenericErrorResponse.Error")
	proto.RegisterType((*Empty)(nil), "anytype.Empty")
	proto.RegisterType((*StreamRequest)(nil), "anytype.StreamRequest")
	proto.RegisterExtension(E_NoAuth)
}

func init() { proto.RegisterFile("pb/protos/commands.proto", fileDescriptor_8261c968b2e6f45c) }

var fileDescriptor_8261c968b2e6f45c = []byte{
	// 12039 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x7b, 0x78, 0x2c, 0x47,
	0x75, 0xe7, 0x9d, 0xe9, 0x79, 0x48, 0x47, 0x8f, 0xdb, 0x6e, 0x2e, 0xd7, 0xa2, 0x6c, 0x5f, 0x1c,
	0xd9, 0xbe, 0x36, 0xd7, 0xb6, 0xae, 0x7d, 0xcd, 0xc3, 0xd7, 0xef, 0xd1, 0xcc, 0x48, 0x1a, 0x5f,
	0x69, 0x46, 0xe9, 0x69, 0xdd, 0x1b, 0x93, 0xcd, 0x6a, 0x5b, 0x33, 0x25, 0xa9, 0xad, 0xd1, 0xf4,
	0xa4, 0xa7, 0xa5, 0x7b, 0x2f, 0xdf, 0xb7, 0x9b, 0x38, 0x89, 0xb1, 0x09, 0x1f, 0x90, 0x07, 0x2c,
	0x38, 0x2c, 0x18, 0xcc, 0x1b, 0x42, 0x08, 0xaf, 0xb0, 0x64, 0x0d, 0x2c, 0x01, 0xf2, 0x11, 0x3e,
	0x82, 0x09, 0xef, 0x64, 0x0d, 0x21, 0x26, 0xcb, 0x92, 0x5d, 0x58, 0x3e, 0x92, 0xec, 0x66, 0x89,
	0x93, 0x65, 0xbf, 0xae, 0xaa, 0x7e, 0xd4, 0x68, 0xba, 0xa7, 0x7b, 0x34, 0x3d, 0x32, 0x9b, 0xbf,
	0x66, 0xba, 0xba, 0xba, 0xea, 0xd4, 0xf9, 0x9d, 0x3a, 0x55, 0x75, 0xea, 0xd4, 0x29, 0x98, 0x6a,
	0xad, 0x9d, 0x6c, 0x19, 0xba, 0xa9, 0xb7, 0x4f, 0xd6, 0xf4, 0xed, 0x6d, 0xb5, 0x59, 0x6f, 0xcf,
	0x90, 0x67, 0x29, 0xab, 0x36, 0x2f, 0x9a, 0x17, 0x5b, 0x18, 0x5d, 0xdd, 0xda, 0xda, 0x38, 0xd9,
	0xd0, 0xd6, 0x4e, 0xb6, 0xd6, 0x4e, 0x6e, 0xeb, 0x75, 0xdc, 0xb0, 0x3f, 0x20, 0x0f, 0x2c, 0x3b,
	0xba, 0xce, 0x2f, 0x57, 0x43, 0xaf, 0xa9, 0x8d, 0xb6, 0xa9, 0x1b, 0x98, 0xe5, 0x3c, 0xea, 0x56,
	0x89, 0x77, 0x71, 0xd3, 0xb4, 0x4b, 0xb8, 0x7c, 0x43, 0xd7, 0x37, 0x1a, 0x98, 0xbe, 0x5b, 0xdb,
	0x59, 0x3f, 0xd9, 0x36, 0x8d, 0x9d, 0x9a, 0xc9, 0xde, 0x5e, 0xd9, 0xf9, 0xb6, 0x8e, 0xdb, 0x35,
	0x43, 0x6b, 0x99, 0xba, 0x41, 0x73, 0x4c, 0x7f, 0xe2, 0xef, 0x52, 0x20, 0xc8, 0xad, 0x1a, 0xfa,
	0xc2, 0x08, 0x08, 0xb9, 0x56, 0x0b, 0xfd, 0x28, 0x09, 0x30, 0x8f, 0xcd, 0xb3, 0xd8, 0x68, 0x6b,
	0x7a, 0x13, 0x8d, 0x42, 0x56, 0xc6, 0xbf, 0xb8, 0x83, 0xdb, 0x26, 0xfa, 0x7a, 0x12, 0x46, 0x64,
	0xdc, 0x6e, 0xe9, 0xcd, 0x36, 0x96, 0xee, 0x81, 0x34, 0x36, 0x0c, 0xdd, 0x98, 0x4a, 0x5c, 0x99,
	0xb8, 0x6e, 0xec, 0xd4, 0x89, 0x19, 0xd6, 0xf0, 0x19, 0xb9, 0x55, 0x9b, 0xc9, 0xb5, 0x5a, 0x33,
	0x6e, 0x19, 0x33, 0xf6, 0x47, 0x33, 0x45, 0xeb, 0x0b, 0x99, 0x7e, 0x28, 0x4d, 0x41, 0x76, 0x97,
	0x66, 0x98, 0x4a, 0x5e, 0x99, 0xb8, 0x6e, 0x54, 0xb6, 0x1f, 0xad, 0x37, 0x75, 0x6c, 0xaa, 0x5a,
	0xa3, 0x3d, 0x25, 0xd0, 0x37, 0xec, 0x11, 0x7d, 0x25, 0x01, 0x69, 0x52, 0x88, 0x94, 0x87, 0x54,
	0x4d, 0xaf, 0x63, 0x52, 0xfd, 0xe4, 0xa9, 0x93, 0xe1, 0xab, 0x9f, 0xc9, 0xeb, 0x75, 0x2c, 0x93,
	0x8f, 0xa5, 0x2b, 0x61, 0xcc, 0x66, 0x88, 0x4b, 0x86, 0x37, 0x69, 0xba, 0x0e, 0x29, 0x2b, 0xbf,
	0x34, 0x02, 0xa9, 0xf2, 0xca, 0xe2, 0xa2, 0x78, 0x48, 0xba, 0x04, 0x26, 0x56, 0xca, 0x67, 0xca,
	0x95, 0x73, 0xe5, 0xd5, 0xa2, 0x2c, 0x57, 0x64, 0x31, 0x21, 0x4d, 0xc0, 0xe8, 0x6c, 0xae, 0xb0,
	0x5a, 0x2a, 0x2f, 0xaf, 0x28, 0x62, 0x52, 0x3a, 0x02, 0xe2, 0xd9, 0xa2, 0x5c, 0x2d, 0x55, 0xca,
	0xab, 0xa5, 0xea, 0x6a, 0x71, 0x69, 0x59, 0xb9, 0x4f, 0x14, 0xac, 0x4c, 0xe5, 0x8a, 0xb2, 0x3a,
	0x57, 0x59, 0x29, 0x17, 0x44, 0x2c, 0x8d, 0x41, 0x56, 0x29, 0x2d, 0x15, 0x2b, 0x2b, 0x8a, 0xb8,
	0x8e, 0x3e, 0x24, 0xc0, 0x64, 0x15, 0x9b, 0x05, 0xbc, 0xab, 0xd5, 0x70, 0xd5, 0x54, 0x4d, 0x8c,
	0x5e, 0x95, 0x70, 0x18, 0x2f, 0xad, 0x58, 0x64, 0x3a, 0xaf, 0x58, 0x93, 0x6f, 0xd9, 0xd3, 0x64,
	0xbe, 0x84, 0x19, 0xf6, 0xf5, 0x8c, 0x27, 0x4d, 0xf6, 0x96, 0x33, 0x7d, 0x23, 0x8c, 0x79, 0xde,
	0x49, 0x93, 0x00, 0xb3, 0xb9, 0xfc, 0x99, 0x79, 0x99, 0x50, 0x78, 0xc8, 0x7a, 0x9e, 0xab, 0xc8,
	0x45, 0xf6, 0x9c, 0x40, 0xaf, 0xf2, 0xc2, 0x5f, 0xe0, 0xe1, 0x9f, 0xe9, 0x4d, 0x4c, 0x17, 0x11,
	0x40, 0x8f, 0x3b, 0x70, 0xce, 0x73, 0x70, 0xde, 0x12, 0xad, 0xb8, 0x68, 0x90, 0x2e, 0xf4, 0x07,
	0x69, 0xb9, 0x52, 0x28, 0xae, 0x5a, 0x08, 0x56, 0x95, 0x9c, 0xac, 0x14, 0x0b, 0x22, 0x46, 0xaf,
	0x4f, 0xc2, 0x48, 0x75, 0x73, 0xc7, 0xac, 0xeb, 0xe7, 0xb9, 0x8e, 0xf2, 0xab, 0x5e, 0x4e, 0xdd,
	0xc5, 0x73, 0xea, 0xba, 0xbd, 0x4d, 0x63, 0x25, 0xf8, 0xf0, 0xe8, 0x0f, 0x1c, 0x1e, 0xe5, 0x38,
	0x1e, 0xdd, 0x18, 0xb6, 0xa0, 0x83, 0xe2, 0xce, 0x57, 0x27, 0x20, 0x73, 0x4e, 0x6d, 0x34, 0xb0,
	0x89, 0xfe, 0x3a, 0x09, 0x99, 0xbc, 0x81, 0x2d, 0xb9, 0xbe, 0xde, 0x15, 0x6b, 0x04, 0x23, 0x86,
	0xae, 0x9b, 0xcb, 0xaa, 0xb9, 0x49, 0xda, 0x34, 0x2a, 0x3b, 0xcf, 0xb7, 0xa5, 0x1e, 0xfe, 0xae,
	0x90, 0x40, 0xbf, 0xeb, 0x65, 0xe4, 0xdd, 0x3c, 0x23, 0x9f, 0xc7, 0xb5, 0x9f, 0x56, 0x34, 0x43,
	0x2b, 0xf1, 0x51, 0x38, 0x08, 0x46, 0xb6, 0x9b, 0x78, 0x5b, 0x6f, 0x6a, 0x35, 0xd6, 0x72, 0xe7,
	0x19, 0xfd, 0x91, 0xc3, 0xe5, 0x59, 0x8e, 0xcb, 0x33, 0xa1, 0x6b, 0x89, 0xc6, 0xe6, 0x6a, 0x1f,
	0x6c, 0x7e, 0x2e, 0x5c, 0x36, 0x97, 0x2b, 0x2d, 0x16, 0x0b, 0xab, 0x4a, 0x65, 0x35, 0x2f, 0x17,
	0x73, 0x4a, 0x71, 0x75, 0xb1, 0x92, 0xcf, 0x2d, 0xae, 0xca, 0xc5, 0xe5, 0x8a, 0x88, 0xd1, 0x7f,
	0x4b, 0x5a, 0xcc, 0xad, 0xe9, 0xbb, 0xd8, 0x40, 0xf3, 0xa1, 0xf8, 0x1c, 0xc4, 0x13, 0x86, 0xc1,
	0x6f, 0x85, 0xd6, 0xfa, 0x8c, 0x3b, 0x8c, 0x02, 0x1f, 0x71, 0xfe, 0x54, 0x28, 0x0d, 0x1e, 0x58,
	0xd4, 0x33, 0x80, 0xd3, 0x7f, 0x9f, 0x84, 0x6c, 0x5e, 0x6f, 0xee, 0x62, 0xc3, 0x44, 0x77, 0x73,
	0x9c, 0x76, 0xb8, 0x99, 0xe0, 0xb9, 0x69, 0x0d, 0x6a, 0xb8, 0x69, 0x1a, 0x7a, 0xeb, 0xa2, 0x3d,
	0xdc, 0xb1, 0x47, 0xf4, 0x8e, 0xa8, 0x1c, 0x66, 0x35, 0xfb, 0x8f, 0xab, 0xdd, 0x2b, 0xe2, 0xc8,
	0x13, 0x3a, 0x3a, 0xc0, 0x63, 0x51, 0x70, 0xe9, 0x4e, 0x40, 0x34, 0x5c, 0x4e, 0x45, 0xc7, 0x05,
	0x7d, 0x29, 0x09, 0x13, 0xb4, 0xf3, 0x55, 0x71, 0x9b, 0x4c, 0x4f, 0xae, 0x0f, 0xc5, 0x7c, 0x26,
	0xca, 0xbf, 0xed, 0x65, 0xf4, 0x1c, 0xcf, 0xe8, 0x9b, 0xfc, 0x3b, 0x3a, 0xab, 0xcb, 0x87, 0xdd,
	0x47, 0x20, 0x6d, 0xea, 0x5b, 0xd8, 0x6e, 0x23, 0x7d, 0x40, 0xef, 0x74, 0xd8, 0x59, 0xe2, 0xd8,
	0xf9, 0x82, 0xa8, 0xd5, 0xc4, 0xcf, 0xd4, 0xf7, 0x26, 0x61, 0x3c, 0xdf, 0xd0, 0xdb, 0x0e, 0x4f,
	0x9f, 0xeb, 0xf2, 0xd4, 0x69, 0x5c, 0xc2, 0xdb, 0xb8, 0xa7, 0x13, 0x1e, 0x3e, 0x16, 0x79, 0x3e,
	0x76, 0x97, 0x17, 0x4f, 0xf1, 0x3e, 0x7a, 0xe1, 0x1d, 0x0e, 0xc3, 0x16, 0x38, 0x86, 0x3d, 0x3f,
	0x62, 0x79, 0xf1, 0xf3, 0xeb, 0xdb, 0x3f, 0x03, 0xd9, 0x5c, 0xad, 0xa6, 0xef, 0x34, 0x4d, 0xf4,
	0x97, 0x09, 0xc8, 0xe4, 0xf5, 0xe6, 0xba, 0xb6, 0x21, 0x1d, 0x87, 0x49, 0xdc, 0x54, 0xd7, 0x1a,
	0xb8, 0xa0, 0x9a, 0xea, 0xae, 0x86, 0xcf, 0x93, 0x06, 0x8c, 0xc8, 0x1d, 0xa9, 0x16, 0x51, 0x2c,
	0x05, 0xaf, 0xed, 0x6c, 0x10, 0xa2, 0x46, 0x64, 0x6f, 0x92, 0x74, 0x2b, 0x5c, 0x4a, 0x1f, 0x97,
	0x0d, 0x6c, 0xe0, 0x06, 0x56, 0xdb, 0x38, 0xbf, 0xa9, 0x36, 0x9b, 0xb8, 0x41, 0x7a, 0xed, 0x88,
	0xec, 0xf7, 0x5a, 0x9a, 0x86, 0x71, 0xfa, 0xaa, 0xda, 0x52, 0x6b, 0xb8, 0x3d, 0x95, 0x22, 0xd9,
	0xb9, 0x34, 0xe9, 0x46, 0x48, 0xe3, 0x0b, 0xa6, 0xa1, 0x4e, 0xd5, 0x09, 0x5e, 0x97, 0xce, 0xd0,
	0x25, 0xc2, 0x8c, 0xbd, 0x44, 0x98, 0xa9, 0x92, 0x05, 0x84, 0x4c, 0x73, 0xa1, 0x4f, 0x65, 0x9c,
	0xa1, 0xfb, 0xcd, 0x9e, 0x29, 0xa9, 0x04, 0xa9, 0xa6, 0xba, 0x8d, 0x99, 0x5c, 0x90, 0xff, 0xd2,
	0x09, 0x38, 0xac, 0xee, 0xaa, 0xa6, 0x6a, 0x2c, 0x5a, 0x8b, 0x17, 0x32, 0xdc, 0x10, 0x96, 0x2f,
	0x1c, 0x92, 0x3b, 0x5f, 0x48, 0x97, 0xc3, 0x28, 0x59, 0xdd, 0x90, 0x5c, 0x54, 0x17, 0xb9, 0x09,
	0xd2, 0x75, 0x70, 0x58, 0x6d, 0xb4, 0x36, 0xd5, 0x52, 0x73, 0x57, 0x33, 0xb1, 0x85, 0xd0, 0xd4,
	0x11, 0x92, 0xa7, 0x33, 0x99, 0x76, 0xec, 0xd9, 0x11, 0xc8, 0xd0, 0x0a, 0xd0, 0xab, 0xd3, 0xa1,
	0xd7, 0x28, 0x14, 0xc2, 0xe0, 0x29, 0xc3, 0x4d, 0x90, 0x55, 0x69, 0x3e, 0xd2, 0x94, 0xb1, 0x53,
	0x47, 0x9d, 0x32, 0xc8, 0x72, 0xcd, 0x2e, 0x45, 0xb6, 0xb3, 0x49, 0xb7, 0x40, 0xa6, 0x46, 0x04,
	0x82, 0xb4, 0x6a, 0xec, 0xd4, 0x65, 0xdd, 0x2b, 0x25, 0x59, 0x64, 0x96, 0x15, 0x7d, 0x4b, 0x08,
	0xb5, 0xac, 0x09, 0xa2, 0x38, 0x9a, 0xdc, 0xff, 0x20, 0xd9, 0xc7, 0xa8, 0x78, 0x03, 0x5c, 0x97,
	0xcb, 0xe7, 0x2b, 0x2b, 0x65, 0x85, 0x8d, 0x89, 0x85, 0xd5, 0xd9, 0x15, 0x65, 0xd5, 0x1d, 0x29,
	0xc9, 0xdc, 0x6f, 0xd5, 0x9a, 0x0a, 0x8a, 0x96, 0x34, 0x1c, 0xef, 0x91, 0xbb, 0xa8, 0xac, 0x96,
	0x73, 0x4b, 0x45, 0x71, 0x3d, 0x44, 0xc9, 0x45, 0x65, 0x35, 0x77, 0x36, 0xa7, 0xe4, 0x64, 0x71,
	0x83, 0x1f, 0x9d, 0xab, 0x4a, 0x65, 0x79, 0x55, 0x5e, 0x29, 0x97, 0x4b, 0xe5, 0x79, 0x5a, 0xb5,
	0x35, 0xa9, 0x39, 0xea, 0x66, 0x38, 0x27, 0x97, 0x94, 0xe2, 0x6a, 0xbe, 0x52, 0x9e, 0x2b, 0xcd,
	0x8b, 0x5a, 0xaf, 0xa1, 0xfd, 0x7e, 0xe9, 0x08, 0x1c, 0xa6, 0x8d, 0x3e, 0x4b, 0xbf, 0x2b, 0x14,
	0xc5, 0x5f, 0xcb, 0x4a, 0x93, 0x30, 0x5a, 0x2e, 0x2a, 0x8c, 0x33, 0x0f, 0x66, 0xa5, 0xcb, 0xe0,
	0xa8, 0xf5, 0x9c, 0xaf, 0x94, 0xcb, 0xc5, 0xbc, 0x62, 0x2d, 0xf5, 0xe4, 0xe2, 0xdc, 0x4a, 0xb5,
	0x58, 0x10, 0x5f, 0x9a, 0x95, 0x44, 0x18, 0xb3, 0x5e, 0x56, 0xe6, 0xe6, 0x16, 0x4b, 0xe5, 0xa2,
	0xf8, 0x50, 0x16, 0xbd, 0x2d, 0xe5, 0xce, 0xcc, 0x3c, 0x0b, 0x85, 0x57, 0xa6, 0x3c, 0xd2, 0x9a,
	0xe3, 0xa5, 0xf5, 0xfa, 0xae, 0xd8, 0x07, 0x4f, 0xae, 0x3e, 0xee, 0xc8, 0x51, 0x81, 0x93, 0xa3,
	0x9b, 0x22, 0x94, 0x15, 0x4d, 0x90, 0x3e, 0xdf, 0x8f, 0x20, 0x3d, 0x1b, 0x2e, 0x29, 0x57, 0x56,
	0x19, 0xe2, 0x55, 0x67, 0x49, 0x7c, 0x25, 0x5c, 0x5e, 0x2e, 0x52, 0x60, 0xe4, 0x62, 0xbe, 0x72,
	0xb6, 0x28, 0xaf, 0x9e, 0xcb, 0x2d, 0x2e, 0x16, 0x95, 0xd5, 0xb9, 0x92, 0x5c, 0x55, 0xc4, 0xf5,
	0x5e, 0xe0, 0x6d, 0x48, 0x57, 0xc1, 0x73, 0xdd, 0xe7, 0xd5, 0xe2, 0xcf, 0x95, 0xaa, 0x4a, 0x95,
	0x88, 0x52, 0xbe, 0x22, 0xcb, 0x2b, 0xcb, 0xd6, 0xc2, 0x64, 0x53, 0x3a, 0x0a, 0x92, 0x5b, 0x8a,
	0xbc, 0x52, 0xa6, 0x62, 0xa3, 0x59, 0xf5, 0xb3, 0xfa, 0xec, 0xea, 0xad, 0x05, 0xcd, 0x72, 0x51,
	0x9e, 0xab, 0xc8, 0x4b, 0xc5, 0x82, 0x78, 0x7f, 0x2f, 0xc9, 0xdb, 0x92, 0x8e, 0xc3, 0x74, 0xae,
	0x5c, 0x51, 0x16, 0x8a, 0xf2, 0x6a, 0xae, 0x7c, 0x9f, 0x72, 0xdf, 0x72, 0x71, 0x75, 0x59, 0xae,
	0xe4, 0x8b, 0xd5, 0xea, 0x6a, 0xa9, 0x6a, 0x67, 0x16, 0x1b, 0x16, 0x09, 0xb6, 0xc0, 0x97, 0xaa,
	0xab, 0x85, 0xe2, 0x62, 0xd1, 0x22, 0x6d, 0x1b, 0xbd, 0x42, 0x80, 0x4c, 0x01, 0x37, 0xb0, 0x89,
	0xd1, 0xcf, 0xb8, 0xca, 0xf6, 0x28, 0x64, 0x0c, 0x6c, 0x4d, 0xb8, 0xd8, 0x90, 0xc2, 0x9e, 0xd0,
	0x5f, 0x26, 0xa3, 0x2a, 0x3b, 0x5a, 0xb6, 0x8f, 0xb2, 0x7b, 0x01, 0x64, 0xda, 0xa6, 0x6a, 0xee,
	0xb4, 0x99, 0xae, 0xbb, 0xa2, 0xbb, 0xae, 0x9b, 0xa9, 0x92, 0x4c, 0x32, 0xcb, 0x8c, 0xfe, 0x3c,
	0x11, 0x45, 0x79, 0x75, 0xa5, 0x20, 0x9a, 0xcc, 0x69, 0x7d, 0x88, 0xdc, 0x31, 0x40, 0x1e, 0x86,
	0xe7, 0x16, 0xe5, 0x62, 0xae, 0x70, 0x9f, 0xc3, 0x78, 0x6c, 0x89, 0xa4, 0xf7, 0x7d, 0x5e, 0x29,
	0x9d, 0x2d, 0x8a, 0xeb, 0xe8, 0x53, 0x69, 0xc8, 0x54, 0x71, 0x03, 0xd7, 0x4c, 0x74, 0xbb, 0x8b,
	0xc7, 0x24, 0x24, 0xb5, 0x3a, 0x1b, 0xfa, 0x92, 0x5a, 0x9d, 0x5b, 0x60, 0x25, 0xbb, 0x2e, 0x64,
	0x9f, 0x4e, 0x45, 0x45, 0x8a, 0xd6, 0x7a, 0xb0, 0xc3, 0xd2, 0x67, 0x22, 0x0d, 0x4b, 0x5d, 0x29,
	0x8e, 0x86, 0xec, 0x57, 0x92, 0x31, 0x2c, 0xd6, 0xc2, 0x28, 0x85, 0x75, 0x1f, 0xa5, 0xd0, 0x31,
	0xd8, 0xcc, 0x95, 0xca, 0x85, 0x55, 0x47, 0x4e, 0xca, 0x73, 0x15, 0x71, 0x53, 0x9a, 0x81, 0x13,
	0x9e, 0xd2, 0x2d, 0x8d, 0xc1, 0x6a, 0xc8, 0x95, 0x0b, 0xab, 0x4b, 0xe5, 0xe2, 0x52, 0xa5, 0x5c,
	0xca, 0x53, 0xd3, 0x48, 0x51, 0xa1, 0x5a, 0xa6, 0x43, 0x87, 0x54, 0x8b, 0x39, 0x39, 0xbf, 0x40,
	0xd4, 0x4d, 0xa1, 0x28, 0xde, 0x2f, 0x5d, 0x0b, 0x57, 0x79, 0x48, 0x61, 0xaa, 0x68, 0x59, 0x2e,
	0x16, 0x8a, 0x73, 0xa5, 0xb2, 0x35, 0x34, 0x2e, 0x56, 0xf2, 0x67, 0xaa, 0xe1, 0xb5, 0x0d, 0xfa,
	0xc7, 0x24, 0xa4, 0xaa, 0xa6, 0xde, 0x42, 0xcf, 0x73, 0x65, 0xf8, 0x18, 0x80, 0x81, 0xb7, 0xf5,
	0x5d, 0x32, 0x31, 0x65, 0x7a, 0xc5, 0x93, 0x82, 0xfe, 0x38, 0xbc, 0x0d, 0xcb, 0x51, 0x0b, 0x7a,
	0xcb, 0x67, 0x5c, 0xfa, 0x71, 0x38, 0x1b, 0x96, 0x7f, 0x41, 0xd1, 0xc4, 0xe8, 0xd7, 0x13, 0x7d,
	0x88, 0x11, 0x82, 0xa3, 0x1e, 0x0d, 0x60, 0xe1, 0x65, 0x33, 0x10, 0x4b, 0x97, 0xc2, 0xb3, 0x3a,
	0x30, 0x23, 0x50, 0xad, 0x4b, 0x3f, 0x03, 0x57, 0x78, 0xa1, 0x5a, 0xaa, 0x9c, 0x2d, 0x3a, 0xf2,
	0x51, 0xc8, 0x29, 0x39, 0x71, 0x03, 0x7d, 0x59, 0x80, 0xd4, 0x92, 0xbe, 0x8b, 0xd1, 0x55, 0x2e,
	0xf3, 0xa7, 0x20, 0xdb, 0xc4, 0xe7, 0x3d, 0x06, 0x19, 0xfb, 0x11, 0xbd, 0x4d, 0x88, 0xca, 0x76,
	0xab, 0x6c, 0x1f, 0xb6, 0x7f, 0x23, 0x19, 0x85, 0xed, 0x5d, 0x0a, 0x8a, 0xc6, 0xf6, 0xbf, 0xe9,
	0x87, 0xed, 0x3e, 0xac, 0xc5, 0xd2, 0x34, 0x1c, 0x73, 0x5f, 0x94, 0x0a, 0xc5, 0xb2, 0x52, 0x9a,
	0xbb, 0xcf, 0x65, 0x6e, 0x49, 0x0e, 0xc5, 0xfe, 0x5e, 0xda, 0x21, 0x78, 0xb2, 0x38, 0x05, 0x47,
	0xdc, 0x77, 0xf3, 0x74, 0xbe, 0x67, 0xbd, 0xb9, 0x1f, 0x3d, 0x9e, 0x86, 0x71, 0xaa, 0x2d, 0x57,
	0x5a, 0x75, 0x6b, 0x71, 0x54, 0xe1, 0x0c, 0x11, 0xa6, 0xb6, 0x8d, 0x5f, 0xac, 0x37, 0xed, 0xf5,
	0x91, 0xf3, 0x6c, 0xad, 0x6c, 0x4a, 0xcb, 0x73, 0xd5, 0xaa, 0xa9, 0x1b, 0xea, 0x06, 0xce, 0xd5,
	0xeb, 0x06, 0xe3, 0x64, 0x67, 0x32, 0xfa, 0x62, 0x68, 0x63, 0x05, 0xaf, 0xbd, 0x29, 0x3d, 0x3e,
	0x12, 0xf1, 0x74, 0x28, 0xb3, 0x44, 0x88, 0x02, 0xa3, 0x49, 0xc6, 0xaf, 0x0d, 0xba, 0x43, 0xfa,
	0x83, 0xb6, 0xee, 0x0b, 0xda, 0xc6, 0xf4, 0x43, 0x49, 0x18, 0x55, 0xb4, 0x6d, 0xfc, 0x12, 0xbd,
	0x89, 0xdb, 0x52, 0x16, 0x84, 0xf9, 0x25, 0x45, 0x3c, 0x64, 0xfd, 0x29, 0xe6, 0x15, 0x31, 0x41,
	0xfe, 0x14, 0xad, 0xaa, 0xad, 0x3f, 0x39, 0x45, 0x14, 0xac, 0x3f, 0x4b, 0x45, 0x45, 0x4c, 0x59,
	0x7f, 0xca, 0x45, 0x45, 0x4c, 0x5b, 0x7f, 0x96, 0x17, 0x15, 0x31, 0x63, 0xfd, 0x29, 0x55, 0x15,
	0x31, 0x6b, 0xfd, 0x99, 0xad, 0x2a, 0xe2, 0x88, 0xf5, 0xe7, 0x6c, 0x55, 0x11, 0x47, 0xad, 0x3f,
	0x79, 0x45, 0x11, 0xc1, 0xfa, 0x73, 0x6f, 0x55, 0x11, 0xc7, 0xac, 0x3f, 0xb9, 0xbc, 0x22, 0x8e,
	0x93, 0x3f, 0x45, 0x45, 0x9c, 0xb0, 0xfe, 0x54, 0xab, 0x8a, 0x38, 0x49, 0x4a, 0xae, 0x2a, 0xe2,
	0x61, 0x52, 0x57, 0x49, 0x11, 0x45, 0xeb, 0xcf, 0x42, 0x55, 0x11, 0x2f, 0x21, 0x99, 0xab, 0x8a,
	0x28, 0x91, 0x4a, 0xab, 0x8a, 0xf8, 0x2c, 0x92, 0xa7, 0xaa, 0x88, 0x47, 0x48, 0x15, 0x55, 0x45,
	0x7c, 0x36, 0x21, 0xa3, 0xa8, 0x88, 0x47, 0x49, 0x1e, 0x59, 0x11, 0x2f, 0x25, 0xaf, 0xca, 0x8a,
	0x38, 0x45, 0x08, 0x2b, 0x2a, 0xe2, 0x73, 0xc8, 0x1f, 0x59, 0x11, 0x11, 0x79, 0x95, 0x53, 0xc4,
	0xcb, 0xd0, 0x15, 0x30, 0x3a, 0x8f, 0x4d, 0x8a, 0x2f, 0x12, 0x41, 0x98, 0xc7, 0xa6, 0x77, 0x5d,
	0xf2, 0x86, 0x29, 0x18, 0x3d, 0xa7, 0x1b, 0x5b, 0xed, 0x96, 0x5a, 0xc3, 0xe8, 0xa3, 0x74, 0x47,
	0x30, 0xbf, 0x63, 0x18, 0xb8, 0xc9, 0xe5, 0x7b, 0x34, 0xbc, 0x41, 0xcd, 0x2e, 0x6d, 0xc6, 0x2d,
	0xc9, 0x67, 0x72, 0x73, 0x25, 0x8c, 0x9d, 0xb7, 0x73, 0x97, 0xea, 0xb6, 0x38, 0x79, 0x92, 0xc2,
	0x1a, 0xd7, 0x7a, 0x57, 0x19, 0xbf, 0xb1, 0xe8, 0x7d, 0x49, 0xc8, 0xcc, 0x63, 0x33, 0xd7, 0x68,
	0x78, 0xf9, 0xf6, 0x88, 0x97, 0x6f, 0xb3, 0x3c, 0xdf, 0x6e, 0xf0, 0x6f, 0x44, 0xae, 0xd1, 0xf0,
	0xe1, 0xd9, 0x34, 0x8c, 0x7b, 0x18, 0x64, 0x4d, 0xe0, 0x85, 0xeb, 0x46, 0x65, 0x2e, 0x0d, 0xbd,
	0xd5, 0xe1, 0x5a, 0x91, 0xe3, 0xda, 0xcd, 0x51, 0x2a, 0x8c, 0x9f, 0x63, 0x9f, 0x74, 0xf7, 0x8a,
	0xae, 0x08, 0xb4, 0x37, 0xa1, 0xd7, 0xf6, 0xc1, 0xc5, 0x40, 0x6b, 0x4f, 0x6f, 0xc9, 0x8b, 0xca,
	0xc3, 0x01, 0x98, 0x6a, 0xfa, 0xe1, 0xe1, 0x47, 0x47, 0x20, 0x53, 0x59, 0xbb, 0xdf, 0x5a, 0xb6,
	0x3c, 0x9d, 0x04, 0x21, 0x57, 0xaf, 0xa3, 0x6b, 0xb8, 0xf1, 0x49, 0x27, 0x2f, 0x4b, 0xf6, 0x22,
	0xc6, 0x79, 0x46, 0x9f, 0xef, 0xa3, 0x47, 0xd3, 0x9a, 0x66, 0x72, 0xf5, 0xba, 0xff, 0xc6, 0x9b,
	0x53, 0x61, 0x92, 0xaf, 0x50, 0xba, 0x99, 0xdf, 0xeb, 0x0f, 0x30, 0x48, 0x3a, 0x4e, 0x00, 0x51,
	0xbb, 0xbf, 0x2f, 0x7d, 0xf1, 0x03, 0xf1, 0x8d, 0x24, 0x64, 0x17, 0xb5, 0xb6, 0x69, 0x21, 0x70,
	0xad, 0x8b, 0xc0, 0xe5, 0x30, 0x6a, 0x33, 0xa0, 0x3d, 0x95, 0x20, 0x7d, 0xd5, 0x4d, 0x40, 0x6f,
	0xf1, 0x62, 0x70, 0x2f, 0x8f, 0xc1, 0xf3, 0x83, 0xdb, 0xc8, 0xea, 0xf2, 0xc1, 0x81, 0xab, 0x36,
	0xd9, 0x59, 0xed, 0xef, 0x3a, 0x6c, 0x5d, 0xe2, 0xd8, 0x7a, 0xba, 0x9f, 0x2a, 0xe3, 0x67, 0xed,
	0x57, 0x93, 0x00, 0x56, 0xdd, 0x32, 0x59, 0xb3, 0x84, 0xe7, 0xee, 0x1b, 0xbc, 0xdc, 0x5d, 0xe2,
	0xb9, 0xfb, 0xa2, 0xde, 0x4d, 0xa5, 0xd5, 0xf9, 0x30, 0x58, 0x04, 0x41, 0x73, 0x58, 0x6b, 0xfd,
	0x45, 0xef, 0x73, 0x98, 0xba, 0xcc, 0x31, 0xf5, 0x8e, 0x3e, 0x6b, 0x8a, 0x9f, 0xaf, 0xff, 0x23,
	0x09, 0x62, 0x15, 0x9b, 0xa5, 0xf6, 0x82, 0xb6, 0xb1, 0xd9, 0xd0, 0x36, 0x36, 0x4d, 0x5c, 0x47,
	0x67, 0x42, 0x69, 0x0f, 0xe9, 0x6a, 0x98, 0xd0, 0xbc, 0xdf, 0xb1, 0xdd, 0x0d, 0x3e, 0x11, 0xbd,
	0xcc, 0x8b, 0xc0, 0x22, 0x8f, 0xc0, 0x0b, 0x7d, 0xf8, 0xd2, 0x49, 0x91, 0xcf, 0xfc, 0xf6, 0xf7,
	0x1c, 0x76, 0x57, 0x38, 0x76, 0xdf, 0xde, 0x5f, 0xb1, 0x43, 0xd9, 0x7c, 0xb3, 0x0d, 0x4c, 0x9e,
	0xad, 0xcc, 0x8e, 0x81, 0x28, 0xb1, 0x77, 0x20, 0xfa, 0x5f, 0x89, 0xe8, 0x63, 0x5f, 0x90, 0x49,
	0x29, 0xf2, 0xc8, 0x36, 0x00, 0x6b, 0x4f, 0x3f, 0xfc, 0xfa, 0x55, 0x01, 0x32, 0xc5, 0x0b, 0x2d,
	0x9d, 0xdf, 0x77, 0x97, 0x20, 0xd5, 0x72, 0x17, 0xd3, 0xe4, 0x7f, 0x88, 0xc1, 0xfc, 0x23, 0x7d,
	0xcc, 0x1f, 0x68, 0xdd, 0x3e, 0xdd, 0xdf, 0x26, 0x23, 0xe9, 0x21, 0xe3, 0x06, 0x48, 0x13, 0x7f,
	0x3d, 0x36, 0xba, 0xb9, 0x86, 0x3a, 0xbb, 0x88, 0xa2, 0xf5, 0x56, 0xa6, 0x99, 0x22, 0xa3, 0xd0,
	0x95, 0x9c, 0xf8, 0x51, 0xf8, 0xbb, 0xd7, 0x24, 0x9c, 0x09, 0xc6, 0xcb, 0x52, 0x90, 0xaa, 0xb4,
	0x70, 0x13, 0xbd, 0x37, 0xc1, 0xa9, 0xe0, 0x9a, 0xde, 0x34, 0xf1, 0x05, 0x57, 0x4b, 0xb8, 0x09,
	0x81, 0xf3, 0x81, 0x29, 0xc8, 0x9a, 0x06, 0x85, 0x8c, 0xf9, 0xfe, 0xb1, 0x47, 0xa9, 0x0c, 0xd3,
	0x5a, 0xb3, 0xd6, 0xd8, 0xa9, 0x63, 0x19, 0x37, 0x54, 0x8b, 0xf6, 0x76, 0xae, 0x5d, 0xc0, 0x2d,
	0xdc, 0xac, 0xe3, 0xa6, 0x49, 0xa9, 0xb1, 0xb7, 0x3c, 0x43, 0xe4, 0xe4, 0x17, 0xd8, 0x77, 0xf2,
	0xf0, 0x5f, 0xcb, 0xf1, 0x9b, 0x29, 0x65, 0xab, 0x95, 0x3e, 0xc8, 0x9f, 0x06, 0xa0, 0x2d, 0x38,
	0xab, 0xe1, 0xf3, 0xcc, 0x26, 0xfb, 0x9c, 0x0e, 0x9b, 0x6c, 0xc5, 0xc9, 0x20, 0x7b, 0x32, 0xa3,
	0x3f, 0x71, 0x20, 0xbf, 0x87, 0x83, 0xfc, 0x86, 0x90, 0x24, 0x44, 0x43, 0xfb, 0x5f, 0xf5, 0xb1,
	0x10, 0xe7, 0x3c, 0x17, 0x05, 0xe9, 0x39, 0xf0, 0x6c, 0xdb, 0xda, 0x58, 0x2e, 0x16, 0x0b, 0xd5,
	0xd5, 0x95, 0xe5, 0x79, 0x39, 0x57, 0x28, 0x8a, 0x80, 0x1e, 0x4f, 0x42, 0x9a, 0xec, 0xcd, 0xa3,
	0xfc, 0x00, 0x64, 0x01, 0xfd, 0x20, 0x11, 0xd6, 0x18, 0xc6, 0xd8, 0x43, 0xea, 0xf6, 0x51, 0x70,
	0x6f, 0x0a, 0x65, 0x83, 0x0c, 0x28, 0x28, 0xfe, 0x6e, 0x65, 0x75, 0xa5, 0xea, 0xa6, 0x7e, 0xfe,
	0xff, 0xff, 0xae, 0x64, 0xb5, 0xf2, 0x80, 0xbb, 0x52, 0x17, 0x12, 0x9e, 0x49, 0x5d, 0xe9, 0x91,
	0x94, 0xb3, 0x0c, 0x7e, 0xd4, 0x23, 0x0d, 0x9e, 0xe5, 0x52, 0x22, 0xdc, 0x72, 0x49, 0xca, 0xc1,
	0x84, 0xd6, 0x34, 0xb1, 0xd1, 0x54, 0x1b, 0x73, 0x0d, 0x75, 0x83, 0x4e, 0x4f, 0xbd, 0x3b, 0x40,
	0x94, 0xa7, 0x25, 0x4f, 0x1e, 0x99, 0xff, 0x42, 0x3a, 0x06, 0x60, 0xe2, 0xed, 0x56, 0x43, 0x35,
	0x5d, 0x61, 0xf2, 0xa4, 0xa0, 0xef, 0x87, 0xf6, 0xd3, 0xb4, 0xfb, 0x57, 0x0f, 0x3f, 0x4d, 0x47,
	0xa6, 0x85, 0x0e, 0x99, 0x76, 0x86, 0xd3, 0x54, 0x88, 0xe1, 0xd4, 0xcb, 0xad, 0x74, 0xc8, 0xc5,
	0xe5, 0x9b, 0x43, 0x39, 0x82, 0x06, 0x35, 0x23, 0x7e, 0x3d, 0xf1, 0xa8, 0x00, 0x93, 0xb4, 0xea,
	0x59, 0x5d, 0xdf, 0xda, 0x56, 0x8d, 0x2d, 0x74, 0xc7, 0x7e, 0x44, 0x04, 0x7d, 0xc1, 0x8b, 0xdf,
	0x3c, 0x8f, 0xdf, 0xcd, 0xfe, 0x0d, 0xb7, 0x6b, 0x1f, 0xce, 0xb2, 0xff, 0x5d, 0x0e, 0x32, 0xf7,
	0x72, 0xc8, 0xbc, 0x30, 0x32, 0x81, 0xf1, 0x23, 0xf4, 0x7e, 0x07, 0x21, 0x5b, 0x6d, 0xee, 0x13,
	0xa1, 0x6f, 0xf7, 0x87, 0x90, 0x5d, 0x7b, 0x1f, 0x08, 0x89, 0x20, 0x6c, 0xe1, 0x8b, 0xac, 0x03,
	0x5a, 0x7f, 0xbd, 0x64, 0xa7, 0xe2, 0xc3, 0xcc, 0x87, 0xe4, 0xa1, 0x60, 0x76, 0x84, 0x27, 0xa1,
	0xd2, 0x1a, 0x00, 0x72, 0x7f, 0x11, 0xda, 0xde, 0xd0, 0x95, 0x0d, 0x94, 0x86, 0xe1, 0xf4, 0xb0,
	0x70, 0xc6, 0x8a, 0xf0, 0x64, 0xc6, 0x8f, 0xd9, 0xd7, 0x53, 0x30, 0x6a, 0x7b, 0xcf, 0x9a, 0xe8,
	0x23, 0x09, 0xce, 0x67, 0xa6, 0xad, 0xef, 0x18, 0x35, 0xcc, 0x2c, 0x40, 0xec, 0xc9, 0xcb, 0x96,
	0x64, 0xc8, 0x01, 0xb4, 0xc7, 0xe8, 0xb7, 0x77, 0x80, 0x4d, 0x45, 0x1d, 0x60, 0xd1, 0xab, 0x84,
	0xb0, 0x4b, 0x51, 0x8e, 0xfb, 0x55, 0x6c, 0x3e, 0x13, 0xc7, 0xd0, 0x4f, 0x86, 0x5a, 0xc5, 0xf6,
	0x68, 0x49, 0x34, 0xe1, 0xa9, 0xf4, 0x31, 0x19, 0xbb, 0x0c, 0x2e, 0xb5, 0x73, 0x54, 0x66, 0xef,
	0x2d, 0xe6, 0x95, 0x55, 0x32, 0x13, 0x5b, 0x91, 0x17, 0x45, 0x01, 0x3d, 0x98, 0x02, 0x91, 0x92,
	0x46, 0xe9, 0x54, 0x2e, 0xb6, 0x30, 0xfa, 0xa5, 0x03, 0x9e, 0x88, 0xa1, 0x1f, 0x7a, 0x95, 0x49,
	0x89, 0x97, 0x93, 0x5b, 0xfc, 0xb9, 0xeb, 0x36, 0xc1, 0x47, 0x5c, 0xfa, 0xe8, 0x15, 0x01, 0x12,
	0x86, 0x3e, 0xeb, 0x08, 0xc0, 0x22, 0x27, 0x00, 0xb7, 0xf6, 0x41, 0xe2, 0x01, 0xcb, 0xc1, 0xe7,
	0x92, 0x30, 0x61, 0x4f, 0x23, 0xe6, 0xb0, 0x59, 0xdb, 0x44, 0xa7, 0xc3, 0xae, 0xcd, 0x44, 0x10,
	0x76, 0x8c, 0x06, 0xa3, 0xd2, 0xfa, 0x8b, 0xfe, 0x39, 0x11, 0x76, 0x77, 0x85, 0xf1, 0x86, 0xab,
	0xd9, 0x67, 0x61, 0x1b, 0x6e, 0x3b, 0x24, 0x44, 0x81, 0xf1, 0xab, 0xeb, 0x6f, 0x26, 0x01, 0x14,
	0xdd, 0x99, 0xb4, 0xee, 0x83, 0x93, 0xdc, 0x51, 0x8e, 0x3c, 0xcf, 0xc9, 0xae, 0x2b, 0x7a, 0xb7,
	0xda, 0xe8, 0x63, 0x29, 0x7a, 0x9b, 0xc3, 0xe2, 0x39, 0x8e, 0xc5, 0xa7, 0x22, 0xd5, 0x14, 0x3f,
	0x7f, 0x1f, 0x4f, 0xc2, 0x68, 0x61, 0xa7, 0xd5, 0xd0, 0x6a, 0xd6, 0xba, 0xf1, 0xda, 0x90, 0xec,
	0x45, 0x0f, 0x26, 0x23, 0x8e, 0x3e, 0x4e, 0x1d, 0x3e, 0xbc, 0xa4, 0x0e, 0x92, 0x49, 0xdb, 0x41,
	0x32, 0xa4, 0x59, 0xb3, 0x47, 0xe1, 0x43, 0x10, 0x4f, 0x01, 0x0e, 0x57, 0x5a, 0xb8, 0x39, 0x6b,
	0x60, 0xb5, 0x5e, 0x33, 0x76, 0xb6, 0xd7, 0xda, 0x28, 0x17, 0x56, 0x46, 0x3d, 0xd6, 0x96, 0x24,
	0x67, 0x6d, 0x41, 0x2f, 0xf5, 0x0e, 0xee, 0x0b, 0x3c, 0x7b, 0x4f, 0xf9, 0x59, 0xf9, 0x3c, 0x34,
	0xf4, 0x31, 0xf9, 0x8b, 0x64, 0x75, 0xee, 0x30, 0xb9, 0xa4, 0xa2, 0x98, 0x5c, 0xde, 0xed, 0x20,
	0x7b, 0x86, 0x43, 0xf6, 0x45, 0xd1, 0xdb, 0x35, 0x94, 0xcd, 0x83, 0xc9, 0x2a, 0x36, 0x7d, 0xe0,
	0xbd, 0x1a, 0x26, 0xd6, 0xdc, 0x37, 0x0e, 0xc4, 0x7c, 0x62, 0x97, 0x2d, 0xbe, 0xf7, 0x46, 0x5d,
	0x9a, 0xf1, 0x24, 0xf8, 0xa0, 0xeb, 0x20, 0x98, 0x0c, 0xb3, 0x6f, 0x10, 0x69, 0x9d, 0x15, 0x58,
	0x7f, 0xfc, 0x28, 0xbc, 0x47, 0x80, 0xc9, 0xd2, 0x76, 0x4b, 0x37, 0xcc, 0x25, 0xd5, 0xd8, 0x22,
	0x67, 0xa7, 0xe7, 0xc3, 0x76, 0xb2, 0x63, 0x00, 0x1a, 0xf9, 0xd4, 0xe3, 0x6b, 0xed, 0x49, 0x41,
	0x4f, 0x44, 0xc5, 0x82, 0x27, 0xc4, 0xdf, 0x2f, 0xc4, 0xd0, 0x75, 0x73, 0x51, 0x6b, 0x6e, 0xb9,
	0x3b, 0xe7, 0xde, 0xa4, 0x88, 0xbb, 0x3c, 0x91, 0xd0, 0x0a, 0xa4, 0x30, 0x7e, 0xb4, 0x3e, 0x9d,
	0x84, 0xb1, 0xea, 0xa6, 0x6a, 0xe0, 0xd9, 0x8b, 0x56, 0x63, 0xc3, 0xfa, 0x91, 0xbc, 0xc2, 0x0b,
	0x84, 0x04, 0xa9, 0x86, 0xd6, 0xdc, 0xb2, 0xb7, 0xe7, 0xac, 0xff, 0x6e, 0x00, 0x81, 0x64, 0x97,
	0x00, 0x02, 0x8e, 0x89, 0xd6, 0xa9, 0xd7, 0x67, 0xee, 0xf3, 0xf6, 0x50, 0x01, 0x04, 0x7a, 0x16,
	0x17, 0x3f, 0x1b, 0xbf, 0x96, 0x84, 0xc3, 0xb9, 0x7a, 0xfd, 0x9c, 0x66, 0x6e, 0x56, 0x6c, 0x1e,
	0xdd, 0x1d, 0x6e, 0x53, 0x7d, 0x0a, 0xb2, 0x2d, 0xf5, 0x62, 0x43, 0x57, 0x9d, 0x81, 0x85, 0x3d,
	0xa2, 0x07, 0x92, 0x11, 0x07, 0x96, 0x0e, 0x0a, 0x7c, 0x98, 0x1a, 0x49, 0xa7, 0x07, 0x17, 0x19,
	0x3f, 0x63, 0xff, 0x34, 0x05, 0x99, 0x2a, 0x56, 0x8d, 0xda, 0x26, 0x7a, 0x43, 0xd2, 0x65, 0xe8,
	0x1c, 0x64, 0xd7, 0xb5, 0x86, 0x89, 0x0d, 0xea, 0x01, 0xe2, 0x9d, 0xc7, 0xd0, 0xf1, 0x6c, 0xb6,
	0xa1, 0xd7, 0xb6, 0x66, 0xf2, 0x96, 0x66, 0x69, 0x9a, 0x33, 0xf6, 0xe9, 0xcc, 0x99, 0x39, 0xf2,
	0x91, 0x6c, 0x7f, 0x2c, 0xdd, 0x03, 0xe9, 0xb6, 0x6e, 0x98, 0xf6, 0x5a, 0xed, 0x44, 0xb8, 0x52,
	0xaa, 0xba, 0x61, 0xca, 0xf4, 0x43, 0x0b, 0xda, 0xf5, 0x9d, 0x46, 0x43, 0xc1, 0x17, 0x4c, 0x7b,
	0x9d, 0x64, 0x3f, 0x4b, 0x47, 0x21, 0xa3, 0xaf, 0xaf, 0xb7, 0x31, 0x5d, 0x8a, 0xa7, 0x65, 0xf6,
	0x24, 0x1d, 0x81, 0x74, 0x43, 0xdb, 0xd6, 0x4c, 0xb2, 0xe2, 0x4e, 0xcb, 0xf4, 0x41, 0x3a, 0x01,
	0xa2, 0xee, 0xac, 0x92, 0x28, 0xa1, 0x53, 0x19, 0xa2, 0x8b, 0xf6, 0xa4, 0x5b, 0x5d, 0x6e, 0x0b,
	0x5f, 0x6c, 0x4f, 0x65, 0xc9, 0x7b, 0xf2, 0x1f, 0x3d, 0x16, 0xd5, 0x4a, 0x4f, 0xf9, 0xea, 0xbf,
	0x64, 0x34, 0x70, 0x4d, 0x37, 0xea, 0x36, 0x6f, 0xfc, 0x97, 0x8c, 0x2c, 0x5f, 0x34, 0xdb, 0x7a,
	0xd7, 0xca, 0xe3, 0x97, 0xa7, 0xc7, 0x32, 0x90, 0x9e, 0x37, 0xd4, 0xd6, 0x26, 0x7a, 0x47, 0x62,
	0xf0, 0xe2, 0xe4, 0x00, 0x9b, 0xec, 0x05, 0xac, 0xd0, 0x03, 0xd8, 0x94, 0x07, 0xd8, 0x47, 0x92,
	0x90, 0x2a, 0xd6, 0x37, 0x30, 0x67, 0xf4, 0x4a, 0x78, 0x8c, 0x5e, 0x47, 0x21, 0x63, 0xaa, 0xc6,
	0x06, 0x36, 0x19, 0x97, 0xd8, 0x93, 0xe3, 0x55, 0x29, 0x78, 0x4e, 0xf1, 0xbe, 0x08, 0x52, 0x56,
	0xbb, 0x88, 0x44, 0x4e, 0x9e, 0xba, 0xaa, 0x1b, 0x34, 0x84, 0x3f, 0x33, 0x56, 0x8d, 0x33, 0x16,
	0x65, 0x32, 0xf9, 0xa0, 0x13, 0x8f, 0xf4, 0x1e, 0x3c, 0xac, 0xb1, 0x5d, 0xab, 0xe9, 0xcd, 0xd2,
	0xb6, 0xba, 0x81, 0xa7, 0x32, 0x74, 0x6c, 0x77, 0x12, 0xec, 0xb7, 0xc5, 0x6d, 0xfd, 0x7e, 0x6d,
	0x2a, 0xeb, 0xbe, 0x25, 0x09, 0x56, 0x13, 0x36, 0xb5, 0x7a, 0x1d, 0x37, 0xa7, 0x46, 0xe8, 0x19,
	0x38, 0xfa, 0x34, 0x7d, 0x0c, 0x52, 0x16, 0x0d, 0x16, 0xc6, 0x96, 0x62, 0x17, 0x0f, 0x49, 0xe3,
	0x96, 0x94, 0x53, 0xab, 0xa4, 0x98, 0x40, 0x5f, 0x4a, 0x46, 0xdc, 0x43, 0xa6, 0x8d, 0xeb, 0x2e,
	0xf3, 0x37, 0x42, 0xba, 0xa9, 0xd7, 0x71, 0x4f, 0x89, 0xa7, 0xb9, 0xa4, 0xe7, 0x43, 0x1a, 0xd7,
	0x37, 0x70, 0x9b, 0x80, 0x39, 0x76, 0xea, 0x58, 0x30, 0x2f, 0x65, 0x9a, 0x39, 0xda, 0x46, 0x75,
	0x37, 0x6a, 0xe3, 0xef, 0x24, 0xff, 0x27, 0x03, 0x87, 0x69, 0xff, 0xac, 0xee, 0xac, 0x59, 0x45,
	0xad, 0x61, 0xf4, 0x9b, 0x02, 0x17, 0x36, 0xa0, 0xbd, 0xb3, 0xe6, 0x8c, 0x65, 0xf4, 0xc1, 0xdb,
	0x89, 0x92, 0x03, 0xd1, 0xc9, 0x42, 0xbf, 0x3a, 0x99, 0xd3, 0xaf, 0x82, 0xdd, 0x0d, 0x5d, 0x6d,
	0x9c, 0x21, 0xc9, 0xb6, 0x36, 0xee, 0xa2, 0x4b, 0xad, 0x41, 0x59, 0x5d, 0x37, 0xb1, 0x51, 0xaa,
	0x13, 0x79, 0x1c, 0x95, 0xed, 0x47, 0x4b, 0xdf, 0xaf, 0xe1, 0x75, 0xdd, 0xb0, 0x16, 0x82, 0xa3,
	0x54, 0xdf, 0xdb, 0xcf, 0x9e, 0xfe, 0x09, 0x9c, 0x51, 0xfa, 0x3a, 0x38, 0xac, 0x6d, 0x34, 0x75,
	0x03, 0x3b, 0x9e, 0x3d, 0x53, 0xe3, 0xf4, 0x54, 0x48, 0x47, 0xb2, 0x74, 0x03, 0x5c, 0xd2, 0xd4,
	0x0b, 0xb8, 0xc5, 0xf8, 0x4e, 0x51, 0x9d, 0x20, 0x3d, 0x62, 0xef, 0x0b, 0xf4, 0xc5, 0xa8, 0x2b,
	0xcf, 0x0e, 0x50, 0x07, 0xa6, 0xfa, 0xa5, 0xdb, 0x61, 0xbc, 0xce, 0xbc, 0x06, 0x6a, 0x9a, 0xd3,
	0x23, 0x7c, 0xbf, 0xe3, 0x32, 0xbb, 0xe2, 0x94, 0xf2, 0x8a, 0xd3, 0x3c, 0x8c, 0x90, 0x63, 0x2a,
	0x96, 0x3c, 0xa5, 0x3b, 0x8e, 0x4c, 0x93, 0xe9, 0xb6, 0xd3, 0x28, 0x0f, 0x4b, 0x66, 0xf2, 0xec,
	0x13, 0xd9, 0xf9, 0x38, 0xda, 0x7c, 0x27, 0x98, 0x43, 0xf1, 0x77, 0xbd, 0x57, 0xa7, 0xe0, 0xf0,
	0xbc, 0xa1, 0xef, 0xb4, 0xda, 0x6e, 0xd7, 0xf3, 0x06, 0x66, 0xe8, 0xde, 0xf5, 0xac, 0x15, 0x0c,
	0xd3, 0x89, 0x67, 0xb0, 0x1d, 0x17, 0xc6, 0x9b, 0xe4, 0xed, 0x9c, 0xc2, 0x7e, 0x3a, 0xa7, 0x2b,
	0xe2, 0x29, 0xaf, 0x88, 0xa3, 0x27, 0xa3, 0xce, 0x55, 0x3b, 0x1a, 0xe9, 0x23, 0x8a, 0x79, 0xc8,
	0x6c, 0x90, 0x8c, 0x4c, 0x12, 0xaf, 0x0f, 0x47, 0x35, 0x29, 0x5c, 0x66, 0x9f, 0xba, 0x3c, 0x13,
	0x3c, 0x3c, 0x8b, 0x26, 0x16, 0xc1, 0xd4, 0x0e, 0xc1, 0xb4, 0x91, 0x82, 0x71, 0xa7, 0xf6, 0x52,
	0xbd, 0x8d, 0xf4, 0x5e, 0x22, 0xb1, 0xc7, 0x90, 0xe1, 0xe8, 0x39, 0xc1, 0xa3, 0xe7, 0xba, 0x68,
	0xa6, 0xb1, 0xae, 0x9a, 0x09, 0x3d, 0x20, 0x84, 0x0d, 0x0a, 0xc3, 0x77, 0x4b, 0x42, 0xee, 0x33,
	0x59, 0xd1, 0x84, 0x0c, 0x4d, 0xd3, 0xbb, 0x55, 0xf1, 0x4b, 0xc1, 0xc7, 0x93, 0x70, 0x09, 0x55,
	0x50, 0x2b, 0xcd, 0xb6, 0xa3, 0x1e, 0xf8, 0x48, 0x02, 0xa4, 0x4d, 0x6d, 0x67, 0x57, 0x94, 0x3c,
	0xf1, 0x16, 0xe0, 0xc0, 0x23, 0x07, 0x9c, 0x1a, 0xf4, 0xd4, 0xe2, 0xb3, 0x96, 0x0c, 0x77, 0xa8,
	0x20, 0x64, 0xa1, 0x43, 0xd0, 0xae, 0x02, 0x8c, 0x56, 0xb1, 0xb9, 0xa8, 0x5e, 0xd4, 0x77, 0x4c,
	0xa4, 0x86, 0x35, 0x4b, 0xdd, 0x0a, 0x99, 0x06, 0xf9, 0x84, 0x68, 0x90, 0xc9, 0x53, 0x57, 0x76,
	0x35, 0x9e, 0x92, 0xcd, 0x2d, 0x5a, 0xb4, 0xcc, 0xf2, 0xf3, 0x67, 0x3d, 0xc2, 0x98, 0xde, 0x1d,
	0xea, 0x06, 0x62, 0x37, 0x8c, 0x64, 0x98, 0xf7, 0xab, 0x3a, 0x7e, 0x58, 0x5e, 0x2a, 0xc0, 0x04,
	0x71, 0xd5, 0x9f, 0x53, 0x77, 0x75, 0x43, 0x33, 0x71, 0x34, 0x8b, 0xa1, 0xf3, 0x19, 0x3b, 0x8f,
	0xe0, 0x49, 0x41, 0xef, 0x49, 0x46, 0xdc, 0x92, 0xe3, 0xe8, 0x18, 0x08, 0x08, 0x91, 0x36, 0xf0,
	0x82, 0xaa, 0x1f, 0x22, 0x10, 0x39, 0xa3, 0xb6, 0xa9, 0xed, 0xe2, 0x7a, 0x44, 0x20, 0xec, 0xcf,
	0x5c, 0x20, 0x9c, 0x82, 0xfa, 0x03, 0xc2, 0xfe, 0xfc, 0x80, 0x80, 0xf0, 0xa9, 0x3e, 0x7e, 0x20,
	0xde, 0x45, 0x81, 0xf0, 0xf8, 0x26, 0x2c, 0x85, 0x05, 0xe2, 0x6a, 0x98, 0x70, 0xad, 0x0a, 0x2b,
	0x46, 0x83, 0xcd, 0x7a, 0xf8, 0x44, 0xf4, 0xd9, 0x3e, 0xe0, 0xe8, 0xe9, 0x66, 0x10, 0x0d, 0x8e,
	0xcf, 0x44, 0x84, 0xe3, 0x99, 0xea, 0x42, 0xf0, 0x84, 0x40, 0x4f, 0x54, 0x71, 0x9e, 0x1c, 0xf7,
	0x87, 0x85, 0x6b, 0x8f, 0xd7, 0x48, 0x36, 0xb2, 0xd7, 0xc8, 0x17, 0xa2, 0x7a, 0x8d, 0x74, 0x52,
	0x3b, 0x10, 0x38, 0x23, 0x39, 0x85, 0xf4, 0xa0, 0xe0, 0x80, 0x11, 0xfd, 0x9e, 0x00, 0x40, 0x22,
	0x12, 0x53, 0x7f, 0xa7, 0x05, 0xc8, 0xd0, 0xbf, 0xb6, 0xd3, 0x64, 0xc2, 0x75, 0x9a, 0xbc, 0x01,
	0xd2, 0xbb, 0x6a, 0x63, 0x07, 0x3b, 0x3c, 0xea, 0x9c, 0x88, 0x9e, 0xb5, 0xde, 0xca, 0x34, 0x13,
	0xda, 0x0c, 0x2b, 0x15, 0x77, 0x7b, 0x1d, 0x76, 0x2c, 0x79, 0xb8, 0xc6, 0x87, 0x8b, 0x8c, 0xc6,
	0x19, 0xfa, 0xeb, 0xfa, 0x68, 0xbd, 0x2d, 0xaa, 0x03, 0x85, 0xa7, 0xac, 0x41, 0x48, 0x43, 0x24,
	0x97, 0x0a, 0xdf, 0xba, 0xe3, 0x57, 0xb4, 0x5f, 0x48, 0x42, 0x5a, 0xd1, 0xab, 0x98, 0x3b, 0x6f,
	0x16, 0x8c, 0x8d, 0xbb, 0x04, 0x4e, 0x72, 0x4b, 0xe0, 0x5f, 0x8d, 0x6a, 0x8a, 0x24, 0xf5, 0xfa,
	0x87, 0x1d, 0x6d, 0x63, 0x77, 0xeb, 0x9f, 0x3e, 0x44, 0xb3, 0x1d, 0x76, 0x2b, 0x3e, 0x7e, 0x86,
	0x9e, 0x86, 0xc3, 0x2b, 0xcd, 0xba, 0x2e, 0xe3, 0xba, 0xce, 0x6c, 0x31, 0xd6, 0xc2, 0x73, 0xa7,
	0x59, 0xd7, 0x09, 0xad, 0x69, 0x99, 0xfc, 0xb7, 0xd2, 0x0c, 0x5c, 0xd7, 0x99, 0xa1, 0x9c, 0xfc,
	0x47, 0x6f, 0x14, 0x20, 0x65, 0x7d, 0x1b, 0xde, 0xb3, 0xe5, 0xfb, 0x51, 0x0f, 0xa6, 0x58, 0xc5,
	0x0f, 0x42, 0xbe, 0xa5, 0xbb, 0x3d, 0xd6, 0x29, 0xba, 0x29, 0x7c, 0x95, 0x5f, 0x7d, 0x1e, 0x56,
	0x78, 0xac, 0x52, 0xef, 0x8f, 0x72, 0x98, 0xa5, 0x0b, 0xd9, 0xd1, 0x90, 0x2c, 0xf4, 0xa1, 0x22,
	0x45, 0x18, 0xcf, 0xe7, 0xca, 0x24, 0x32, 0xcb, 0x52, 0xe5, 0x6c, 0x51, 0x14, 0x08, 0x40, 0x56,
	0x6b, 0x62, 0x04, 0xc8, 0x2a, 0xfe, 0xa7, 0x10, 0xa0, 0x2e, 0x64, 0x1f, 0x04, 0x40, 0x9f, 0x4b,
	0xc2, 0xc4, 0xa2, 0xd6, 0x36, 0xfd, 0x9c, 0xc4, 0x02, 0xce, 0xcd, 0xbf, 0x2a, 0xea, 0x84, 0x90,
	0xab, 0x27, 0xf4, 0x81, 0xf9, 0x48, 0x73, 0xf0, 0xa0, 0x2a, 0x86, 0xe3, 0xcd, 0x48, 0x28, 0xa0,
	0x01, 0x1b, 0x43, 0x73, 0x32, 0xf2, 0xd0, 0xeb, 0x56, 0x32, 0xfc, 0xa1, 0xd7, 0xb7, 0xee, 0xf8,
	0xf9, 0xfb, 0xd7, 0x49, 0xb8, 0xc4, 0xaa, 0x3e, 0x68, 0xc1, 0xe9, 0xcf, 0xe6, 0x9e, 0x0b, 0xce,
	0xc8, 0x36, 0xaf, 0x3d, 0xb4, 0x0c, 0xc2, 0xe6, 0xd5, 0xab, 0xd0, 0x21, 0xb3, 0xd9, 0xc7, 0xc0,
	0xd2, 0x8b, 0xcd, 0x01, 0x06, 0x96, 0xfe, 0xd9, 0x1c, 0x6c, 0x64, 0xe9, 0x93, 0xcd, 0x07, 0x66,
	0x3a, 0xf9, 0x46, 0x12, 0x26, 0x72, 0xad, 0x56, 0xe3, 0xa2, 0xc2, 0x4e, 0x8e, 0x44, 0x32, 0x9d,
	0x78, 0x0e, 0xa0, 0x24, 0xf7, 0x1c, 0xbf, 0x8c, 0xec, 0x56, 0xce, 0xd1, 0x31, 0x08, 0xb7, 0xf2,
	0xa0, 0x02, 0xe3, 0x67, 0xed, 0x2b, 0xd2, 0x54, 0x11, 0xb3, 0xc0, 0x10, 0x5f, 0x4b, 0x04, 0x47,
	0x86, 0x08, 0x0c, 0x83, 0x23, 0xdd, 0x09, 0x99, 0x75, 0xdd, 0xd8, 0x56, 0x6d, 0x5b, 0xee, 0x35,
	0x7e, 0xe2, 0xc4, 0x62, 0x2f, 0xcc, 0x91, 0xcc, 0x32, 0xfb, 0xc8, 0x1a, 0xd1, 0x5e, 0xa2, 0xb5,
	0xd8, 0xd9, 0x69, 0xeb, 0x2f, 0x09, 0x8a, 0x42, 0x8f, 0x50, 0x97, 0x71, 0xdb, 0xc4, 0x75, 0xb2,
	0x59, 0x39, 0x22, 0xf3, 0x89, 0xd2, 0x34, 0x8c, 0xb3, 0x84, 0x39, 0xad, 0x81, 0xdb, 0x64, 0x0b,
	0x7a, 0x44, 0xe6, 0xd2, 0xd0, 0x97, 0xfb, 0x19, 0x38, 0x22, 0x47, 0xac, 0x98, 0x82, 0x6c, 0x7b,
	0xa7, 0x56, 0xc3, 0xb8, 0xce, 0xbc, 0x92, 0xec, 0xc7, 0x88, 0x5e, 0x8e, 0x91, 0x87, 0x99, 0x83,
	0x09, 0x66, 0x31, 0xbd, 0x0c, 0x19, 0x8a, 0xa1, 0x34, 0x0e, 0x23, 0xb6, 0x9f, 0x25, 0xf5, 0x23,
	0x59, 0x66, 0x8b, 0x74, 0x31, 0x61, 0x95, 0x78, 0x6f, 0xb5, 0x52, 0xa6, 0xc1, 0x01, 0x0b, 0x15,
	0x16, 0x1c, 0xb0, 0x7a, 0x76, 0x5e, 0x4c, 0x49, 0x93, 0x00, 0xf3, 0x72, 0x6e, 0x79, 0x61, 0x95,
	0xe4, 0x48, 0xa3, 0xef, 0x8e, 0x41, 0x86, 0xba, 0x6d, 0xa2, 0x2f, 0x67, 0xbc, 0xd7, 0x38, 0x8d,
	0x37, 0x75, 0x8b, 0xcc, 0x65, 0xd5, 0x50, 0xb7, 0xdb, 0x41, 0x7b, 0x63, 0xf4, 0x6b, 0xe7, 0x0a,
	0xa7, 0xb2, 0xe7, 0xb3, 0x85, 0x43, 0x32, 0x57, 0x8c, 0xf4, 0xaf, 0xe1, 0xf0, 0x1a, 0x3b, 0x70,
	0xd0, 0x66, 0x25, 0x27, 0xfd, 0xb7, 0x55, 0x3b, 0x4a, 0x9e, 0xe5, 0xbf, 0x5c, 0x38, 0x24, 0x77,
	0x16, 0x26, 0xfd, 0x3c, 0x4c, 0x6e, 0x33, 0xae, 0xb0, 0xe2, 0x85, 0x5e, 0xfe, 0xb4, 0x4e, 0xf1,
	0x4b, 0xdc, 0x87, 0x0b, 0x87, 0xe4, 0x8e, 0xa2, 0xa4, 0x12, 0x8c, 0xb6, 0x9b, 0x6a, 0xab, 0xbd,
	0xa9, 0x9b, 0xf6, 0xb9, 0xb9, 0xeb, 0x43, 0x94, 0x5b, 0x65, 0xdf, 0xc8, 0xee, 0xd7, 0xd2, 0xf3,
	0xe1, 0xd9, 0x3b, 0x24, 0x54, 0x65, 0xf1, 0x82, 0xd6, 0x36, 0xb5, 0xe6, 0x86, 0x1d, 0xc7, 0x80,
	0xf6, 0xb7, 0xee, 0x2f, 0xa5, 0xdb, 0x99, 0xbb, 0x53, 0x86, 0xc8, 0xe6, 0xb5, 0x21, 0xea, 0xf6,
	0xb8, 0x3c, 0xdd, 0x0e, 0xa9, 0x6d, 0x4b, 0xb0, 0xb3, 0xa1, 0x3f, 0x5e, 0x22, 0xd2, 0x6c, 0x7d,
	0x84, 0x8e, 0xc3, 0xb8, 0x17, 0x57, 0xe9, 0x28, 0x64, 0xd4, 0x96, 0x76, 0xc6, 0x31, 0x1f, 0xb1,
	0x27, 0x74, 0x35, 0x4c, 0xf2, 0x6c, 0xec, 0xa6, 0xd4, 0xd0, 0x55, 0x70, 0xb8, 0x03, 0x4b, 0xfb,
	0xd4, 0x4c, 0xc2, 0x3d, 0x35, 0xf3, 0x0b, 0x30, 0x62, 0x73, 0x6e, 0x4f, 0x10, 0xeb, 0x1c, 0x8c,
	0xd8, 0xbc, 0x64, 0xf2, 0x73, 0x4d, 0x87, 0x89, 0xb1, 0xba, 0xad, 0x1a, 0x26, 0xd9, 0x50, 0xb7,
	0x0b, 0x99, 0x55, 0xdb, 0x58, 0x76, 0x3e, 0x9b, 0xbe, 0x11, 0x52, 0x56, 0xfb, 0x24, 0x09, 0x26,
	0x73, 0x8b, 0x8b, 0xab, 0x15, 0x12, 0x40, 0x7d, 0xa1, 0x54, 0x9e, 0xa7, 0xfd, 0xb0, 0x34, 0x5f,
	0xae, 0xc8, 0x45, 0xda, 0x0d, 0xab, 0x62, 0x62, 0x7a, 0x86, 0xb9, 0x6e, 0x01, 0x64, 0x28, 0x23,
	0x68, 0xa7, 0x73, 0xba, 0x60, 0xc2, 0x7a, 0x2a, 0x5e, 0xa0, 0x56, 0x40, 0x31, 0x39, 0x3b, 0x02,
	0x99, 0x16, 0x69, 0x19, 0x6f, 0x49, 0x09, 0xe3, 0xc9, 0xe8, 0xa0, 0xd0, 0x6d, 0xa4, 0xfb, 0x70,
	0x14, 0xb7, 0xc4, 0xae, 0x25, 0x45, 0x53, 0x52, 0x73, 0x7b, 0x94, 0x94, 0x04, 0x93, 0xa5, 0xb2,
	0x52, 0x94, 0xcb, 0xb9, 0x45, 0x47, 0x4b, 0xed, 0x51, 0x5c, 0x49, 0x5e, 0x71, 0x09, 0xe8, 0x27,
	0x49, 0x9b, 0x71, 0xe8, 0xef, 0x93, 0x30, 0xa1, 0xe8, 0x5b, 0xb8, 0x79, 0x56, 0x6d, 0x68, 0x24,
	0x1e, 0x2d, 0xbf, 0xe9, 0xdb, 0x55, 0xb0, 0x3e, 0xe1, 0xe5, 0xa2, 0xc2, 0x73, 0xf1, 0xae, 0x80,
	0xb6, 0xd3, 0x3a, 0x67, 0xb8, 0xfa, 0x7c, 0x58, 0xfb, 0xa4, 0xc3, 0xda, 0x73, 0x1c, 0x6b, 0xf3,
	0xfb, 0x2b, 0x3e, 0x1a, 0xbf, 0x7f, 0x2e, 0x14, 0xbf, 0x45, 0x18, 0x5f, 0x29, 0xe7, 0x56, 0x94,
	0x85, 0x8a, 0x5c, 0x7a, 0x71, 0xb1, 0x20, 0x26, 0xf7, 0x22, 0x20, 0xf0, 0x08, 0xa4, 0xd0, 0xf7,
	0x05, 0x00, 0x4a, 0xb5, 0x35, 0x7e, 0x79, 0x23, 0x7c, 0x7e, 0x2d, 0xea, 0x50, 0xed, 0x16, 0xe3,
	0x33, 0x54, 0x97, 0x60, 0xc4, 0x60, 0x2f, 0x98, 0xc9, 0xb7, 0x57, 0x39, 0xf4, 0xaf, 0x5d, 0x9a,
	0xec, 0x7c, 0x8e, 0x3e, 0x1a, 0x65, 0x64, 0xf6, 0x25, 0xec, 0x60, 0x84, 0xfe, 0x25, 0xf6, 0xe1,
	0x11, 0xcf, 0x84, 0x97, 0x6a, 0xf0, 0x70, 0x6d, 0xe0, 0x3f, 0xf6, 0x28, 0xf3, 0xe9, 0x2b, 0x7b,
	0xa9, 0x23, 0xf4, 0xe9, 0xc3, 0x30, 0x49, 0x4b, 0x74, 0xa2, 0x3a, 0xfc, 0x13, 0x0b, 0xaf, 0x79,
	0x26, 0xec, 0x5c, 0x7e, 0x1a, 0xc6, 0x3d, 0x6e, 0x57, 0x4e, 0xa4, 0x56, 0x6f, 0x1a, 0x7f, 0x21,
	0x58, 0xe0, 0x4d, 0x8b, 0x3c, 0x35, 0x01, 0x21, 0x38, 0xa3, 0x59, 0x08, 0xa2, 0x1c, 0xab, 0x08,
	0xa8, 0x3c, 0xfe, 0x99, 0xff, 0x83, 0xee, 0x7d, 0x19, 0x03, 0x45, 0x20, 0xea, 0x99, 0x2e, 0x87,
	0x09, 0xe1, 0xcc, 0x34, 0x03, 0x3f, 0x25, 0x14, 0x5c, 0x7f, 0xfc, 0x38, 0xfc, 0x84, 0xd9, 0x15,
	0x73, 0xbb, 0xaa, 0xd6, 0x50, 0xd7, 0x1a, 0x11, 0x0e, 0x9f, 0x7e, 0xda, 0xcb, 0xea, 0x32, 0xcf,
	0xea, 0x5b, 0x83, 0x9a, 0xca, 0xd5, 0xe7, 0x7b, 0xa5, 0xc9, 0xa8, 0x8d, 0xab, 0xeb, 0x42, 0xc6,
	0xcf, 0x6a, 0xec, 0xf2, 0x64, 0x37, 0x27, 0xfa, 0x7d, 0x87, 0xf5, 0x3f, 0xcb, 0xb1, 0xfe, 0xce,
	0x7e, 0xe9, 0x89, 0x1f, 0x81, 0x57, 0x0a, 0x30, 0x96, 0xab, 0xd7, 0xe7, 0xb0, 0x6a, 0xee, 0x18,
	0xb8, 0x8e, 0x8a, 0x61, 0xbb, 0xc3, 0xe5, 0x9d, 0x2c, 0x1a, 0xf5, 0x72, 0xe2, 0x23, 0xa1, 0x63,
	0x75, 0xee, 0xd5, 0x06, 0x36, 0x2d, 0x03, 0x51, 0x49, 0xe1, 0x22, 0x7b, 0x86, 0x26, 0x22, 0x7e,
	0x40, 0x5e, 0x2b, 0xc0, 0x24, 0x0d, 0xe1, 0x3a, 0x68, 0x4c, 0x3e, 0xe6, 0xc5, 0xa4, 0xc2, 0x63,
	0x72, 0x3a, 0x88, 0x1d, 0x3c, 0x39, 0x03, 0x81, 0xc5, 0xdd, 0x04, 0x91, 0x39, 0x58, 0xee, 0xea,
	0x9b, 0x8e, 0xf8, 0x91, 0xf9, 0x01, 0x00, 0x78, 0x1c, 0x67, 0xbe, 0x05, 0xee, 0x81, 0x11, 0xf4,
	0x05, 0x81, 0x8e, 0xe7, 0x55, 0xee, 0x5c, 0x30, 0xef, 0x2f, 0x93, 0xe8, 0xe2, 0x2f, 0x13, 0x6a,
	0x54, 0xf9, 0x51, 0x44, 0x3f, 0x0c, 0xe6, 0xca, 0xd2, 0x73, 0x70, 0xef, 0x53, 0xcb, 0x3d, 0x15,
	0xc1, 0x21, 0xa3, 0x17, 0x29, 0xf1, 0xdf, 0xe0, 0x14, 0xe4, 0x90, 0x21, 0x4d, 0xc1, 0x11, 0xb9,
	0x98, 0x2b, 0x54, 0xca, 0x8b, 0xf7, 0x79, 0xdf, 0x8a, 0x29, 0xf4, 0x26, 0x01, 0x32, 0x2c, 0x44,
	0x74, 0x2c, 0x98, 0xfe, 0xe7, 0x88, 0x0a, 0x92, 0x67, 0x64, 0x50, 0x34, 0x69, 0xf4, 0x5f, 0x23,
	0xa8, 0xbc, 0x10, 0xc5, 0x3e, 0x63, 0x21, 0xfa, 0xa6, 0x00, 0x29, 0xb2, 0x7e, 0xda, 0x89, 0x0a,
	0x50, 0x01, 0xae, 0x50, 0x5b, 0x2d, 0xdc, 0xac, 0x3b, 0xc1, 0x29, 0xe7, 0x0c, 0x7d, 0xbb, 0x62,
	0x6e, 0x62, 0xc3, 0xca, 0xd2, 0x66, 0xdb, 0x11, 0xc1, 0x99, 0xd0, 0x37, 0x23, 0xee, 0x50, 0xf0,
	0xbc, 0x0e, 0x58, 0xb2, 0x9d, 0xde, 0xdb, 0x2f, 0x2f, 0xf3, 0xe9, 0x97, 0x8b, 0x5a, 0x73, 0xcb,
	0xdb, 0x37, 0xff, 0x24, 0xc2, 0xe6, 0x46, 0x4f, 0x7a, 0x0e, 0xd8, 0x5b, 0xea, 0x81, 0x8c, 0x47,
	0xc1, 0xbe, 0x4c, 0x00, 0xd1, 0x8d, 0x6e, 0xce, 0x22, 0xac, 0x55, 0xf8, 0xcd, 0x26, 0x92, 0xe8,
	0xdd, 0x6c, 0xb2, 0x13, 0xa4, 0xe3, 0x30, 0x59, 0xdb, 0xc4, 0xb5, 0xad, 0x52, 0xd3, 0x36, 0xee,
	0x51, 0x84, 0x3b, 0x52, 0x79, 0xb7, 0xea, 0x33, 0x3c, 0xa4, 0xfc, 0x06, 0x06, 0xc7, 0x37, 0x2f,
	0x51, 0x3e, 0x9d, 0xd2, 0x05, 0xa6, 0xcc, 0x01, 0x73, 0x5b, 0x5f, 0xa5, 0x46, 0x43, 0xa6, 0xdc,
	0xdf, 0x2d, 0x3a, 0x95, 0x65, 0x72, 0x41, 0xe5, 0x4a, 0xb5, 0x58, 0x58, 0x9d, 0xb5, 0x3b, 0x5f,
	0x55, 0x14, 0xd0, 0xf7, 0x92, 0x90, 0xa5, 0x64, 0xb5, 0x3b, 0xa2, 0x8f, 0x7b, 0x0f, 0x0b, 0x25,
	0xf6, 0x1c, 0x16, 0x42, 0xef, 0x0b, 0xed, 0xb5, 0xee, 0x30, 0x82, 0xd5, 0xe3, 0xd3, 0x53, 0x6e,
	0x85, 0x2c, 0x05, 0xd9, 0xb6, 0x5d, 0x1f, 0xf3, 0xe9, 0x27, 0xac, 0x18, 0xd9, 0xce, 0x1e, 0xd2,
	0x83, 0xbd, 0x07, 0x19, 0xf1, 0xcf, 0x39, 0xde, 0x3e, 0x06, 0xd9, 0x05, 0xad, 0x6d, 0xea, 0xc6,
	0x45, 0xf4, 0xb6, 0x04, 0x64, 0xcf, 0x62, 0xa3, 0xad, 0xe9, 0xcd, 0x3d, 0x56, 0xd8, 0x2b, 0x61,
	0xac, 0x65, 0xe0, 0x5d, 0x4d, 0xdf, 0x69, 0x7b, 0x42, 0x4d, 0x78, 0x92, 0x24, 0x04, 0x23, 0xea,
	0x8e, 0xb9, 0xa9, 0x1b, 0x6e, 0xdc, 0x2d, 0xfb, 0x59, 0x3a, 0x06, 0x40, 0xff, 0x97, 0xd5, 0x6d,
	0xcc, 0x0e, 0xb1, 0x78, 0x52, 0x24, 0x09, 0x52, 0xa6, 0xb6, 0x8d, 0xd9, 0xb1, 0x47, 0xf2, 0x5f,
	0x9a, 0x82, 0x2c, 0x39, 0x06, 0x55, 0xaa, 0xb3, 0x63, 0x8f, 0xf6, 0x23, 0x7a, 0xa7, 0x00, 0x63,
	0xf3, 0xd8, 0x64, 0xa4, 0xb6, 0xbd, 0xc7, 0x21, 0x7a, 0x5c, 0x02, 0xd0, 0x50, 0xdb, 0xf6, 0x67,
	0xce, 0x86, 0x25, 0x9f, 0xe8, 0x1e, 0xc1, 0x14, 0x3c, 0x27, 0xa1, 0xd1, 0x87, 0x93, 0x61, 0x0f,
	0x11, 0x31, 0x66, 0xce, 0x78, 0x08, 0xf4, 0x95, 0xad, 0x91, 0x5d, 0x96, 0x83, 0x29, 0xe1, 0xcb,
	0xbb, 0x96, 0xc4, 0x8a, 0x91, 0x9d, 0xdc, 0x21, 0x0f, 0xfe, 0xf4, 0xa6, 0x24, 0x7e, 0xf1, 0xfa,
	0x07, 0x01, 0xc6, 0xaa, 0x9b, 0xfa, 0x79, 0x46, 0x00, 0xfa, 0x85, 0x70, 0x50, 0x5d, 0x0e, 0xa3,
	0xbb, 0x1d, 0x30, 0xb9, 0x09, 0xfe, 0xf1, 0xa3, 0xd1, 0xc3, 0x42, 0x54, 0x98, 0x3c, 0xc4, 0x0d,
	0x3c, 0xee, 0xb3, 0xf4, 0x42, 0xc8, 0x32, 0xaa, 0x99, 0x65, 0x25, 0x18, 0x60, 0x3b, 0xb3, 0xb7,
	0x81, 0x29, 0xbe, 0x81, 0xd1, 0x90, 0xf7, 0x6f, 0xdc, 0x10, 0xe2, 0x5f, 0x24, 0x89, 0x2b, 0xb2,
	0x0d, 0x7c, 0x7e, 0x00, 0xc0, 0xa3, 0x1f, 0x27, 0xc2, 0xda, 0x1f, 0x1d, 0x0e, 0x38, 0x14, 0xec,
	0x2b, 0x50, 0x4b, 0xcf, 0xe2, 0xe2, 0xe7, 0xe7, 0xaf, 0x5c, 0x02, 0xa9, 0x39, 0xad, 0x81, 0xad,
	0xf5, 0x7b, 0xb6, 0xb2, 0xbe, 0x4e, 0x02, 0xad, 0x14, 0xfd, 0xef, 0x7e, 0x3d, 0x01, 0xa2, 0xbd,
	0x91, 0xaf, 0x9b, 0xcb, 0x5a, 0xb3, 0xe9, 0xf8, 0x1a, 0xed, 0x49, 0xe7, 0x4d, 0x5d, 0x81, 0x0e,
	0xc0, 0x16, 0x05, 0x33, 0xac, 0x76, 0x9f, 0xfe, 0x72, 0x1c, 0x26, 0xd7, 0x2e, 0x9a, 0xb8, 0xcd,
	0x72, 0xb1, 0x6a, 0x53, 0x72, 0x47, 0x2a, 0x7a, 0x22, 0x94, 0x4b, 0x70, 0x40, 0x85, 0xd1, 0x78,
	0xae, 0xf6, 0x31, 0x47, 0x39, 0x02, 0x62, 0xb9, 0x52, 0x28, 0xd2, 0x4b, 0x52, 0x95, 0x9c, 0xac,
	0x14, 0x0b, 0xe2, 0x06, 0xb9, 0x19, 0xb2, 0xb4, 0x48, 0x53, 0xef, 0x2b, 0x2a, 0xab, 0xcb, 0xa5,
	0x72, 0xb9, 0x58, 0x10, 0x37, 0xd1, 0xe3, 0x02, 0x8c, 0x59, 0xf3, 0x2a, 0x1b, 0x9d, 0x0a, 0x77,
	0xb1, 0xa6, 0xde, 0x6c, 0x5c, 0x74, 0xe7, 0x8e, 0xf6, 0x63, 0x24, 0x9c, 0xfe, 0x4b, 0xe8, 0xe9,
	0x0d, 0x61, 0x9b, 0x87, 0x16, 0x7f, 0xac, 0xd6, 0xb5, 0x46, 0x27, 0x56, 0x69, 0xb9, 0x23, 0xb5,
	0x0b, 0xa6, 0x42, 0x57, 0x4c, 0xff, 0x30, 0xd4, 0xa4, 0xa7, 0x07, 0x71, 0xd1, 0x70, 0x5d, 0x18,
	0x14, 0xae, 0xe8, 0x87, 0x02, 0x64, 0x56, 0x5a, 0x04, 0xb9, 0xa7, 0x3c, 0x9e, 0x3a, 0x7b, 0x76,
	0xab, 0x2d, 0x25, 0xd5, 0xd0, 0x6b, 0x6a, 0xc3, 0x13, 0xeb, 0xcb, 0x4d, 0x90, 0x6e, 0x63, 0xdb,
	0x3e, 0xd4, 0x4b, 0xe7, 0x78, 0xe0, 0xb9, 0x6f, 0xc2, 0x09, 0xcf, 0xbe, 0xfd, 0x0d, 0x70, 0x49,
	0x5d, 0x6b, 0xab, 0x6b, 0x0d, 0x5c, 0x6c, 0xd6, 0x8c, 0x8b, 0xb4, 0xd1, 0xd4, 0x65, 0x67, 0xef,
	0x0b, 0xe9, 0x4e, 0x48, 0xb7, 0xcd, 0x8b, 0x0d, 0x3a, 0x6d, 0xf2, 0x6e, 0xf3, 0xfb, 0x56, 0x55,
	0xb5, 0xb2, 0xcb, 0xf4, 0x2b, 0xf4, 0x93, 0x44, 0x58, 0x17, 0x67, 0xf2, 0x2d, 0x65, 0x8d, 0xbf,
	0xbf, 0xce, 0xa6, 0xda, 0x76, 0xfc, 0x75, 0xac, 0xff, 0xe8, 0xd1, 0x50, 0x7e, 0xc8, 0xfe, 0x65,
	0xc7, 0xaf, 0x53, 0x9f, 0x4c, 0xc2, 0x48, 0x41, 0x3f, 0xdf, 0x24, 0x98, 0xdf, 0xcc, 0x39, 0x67,
	0x91, 0xd6, 0x24, 0xdc, 0xd6, 0x74, 0xf3, 0x48, 0x42, 0xff, 0x21, 0xf4, 0x76, 0x3f, 0x69, 0xa5,
	0x5d, 0x95, 0xff, 0x2d, 0x68, 0xfe, 0x62, 0xe5, 0x31, 0xfd, 0x07, 0x39, 0x03, 0x04, 0xd5, 0x13,
	0x8d, 0x9f, 0xb9, 0x7d, 0xdf, 0x22, 0x81, 0x9e, 0x10, 0x20, 0x55, 0x30, 0xf4, 0x16, 0xfa, 0xbd,
	0x44, 0x84, 0x3d, 0xb0, 0xba, 0xa1, 0xb7, 0x14, 0x12, 0x06, 0xc8, 0x99, 0x02, 0x70, 0x69, 0xd2,
	0x69, 0x18, 0x69, 0xe9, 0x6d, 0xcd, 0xb4, 0xa7, 0x55, 0x93, 0x7b, 0x2e, 0x84, 0xa7, 0x92, 0xbf,
	0xcc, 0x32, 0xc9, 0x4e, 0x76, 0x4b, 0x8f, 0x11, 0x8e, 0x5a, 0x6c, 0xb2, 0xb8, 0x6a, 0x87, 0x2b,
	0xea, 0x48, 0x45, 0xaf, 0xf1, 0x02, 0x7b, 0x3b, 0x0f, 0xec, 0x35, 0x5d, 0x18, 0x6e, 0xf8, 0xdd,
	0x30, 0x1d, 0xd1, 0x6a, 0xfd, 0x06, 0x07, 0xe4, 0xbb, 0x38, 0x90, 0x4f, 0x84, 0xaa, 0x33, 0xfe,
	0x0e, 0xf3, 0xfd, 0x2c, 0x40, 0x59, 0xdd, 0xd5, 0x36, 0xa8, 0xcd, 0xe4, 0xeb, 0xf6, 0x80, 0xc7,
	0xac, 0x1b, 0xaf, 0xf4, 0xe0, 0x7c, 0x1a, 0xb2, 0x0c, 0x56, 0xd6, 0x86, 0xe7, 0x72, 0x6d, 0x70,
	0x4b, 0xa1, 0x1a, 0xea, 0x82, 0x29, 0xdb, 0xf9, 0xb9, 0xc8, 0x64, 0xc9, 0x8e, 0xc8, 0x64, 0x5d,
	0x97, 0x67, 0x7e, 0xf1, 0xca, 0xd0, 0x1f, 0x84, 0x0e, 0xee, 0xe1, 0xa1, 0xc7, 0xd3, 0x22, 0x1f,
	0x50, 0x6f, 0x81, 0xac, 0xee, 0x98, 0x79, 0x04, 0xdf, 0xf5, 0x40, 0xa9, 0xb9, 0xae, 0xcb, 0x76,
	0xce, 0x90, 0x61, 0x3b, 0x42, 0xd1, 0x11, 0x3f, 0xd0, 0x5f, 0x14, 0xe0, 0xe8, 0xbc, 0x7d, 0x72,
	0xd5, 0x6a, 0xc7, 0x39, 0xcd, 0xdc, 0x5c, 0xd4, 0x9a, 0x5b, 0x6d, 0xf4, 0x6f, 0xc2, 0xcd, 0xe4,
	0x3d, 0xf8, 0x27, 0xa3, 0xe1, 0xcf, 0xbb, 0x93, 0x56, 0x79, 0xd4, 0xee, 0xf4, 0x2b, 0xa5, 0x3b,
	0xb5, 0x3e, 0x00, 0xde, 0x06, 0x19, 0x4a, 0x28, 0xeb, 0x96, 0xd3, 0xbe, 0xf8, 0x39, 0x25, 0xc9,
	0xec, 0x0b, 0x8f, 0x57, 0xd6, 0x59, 0x0e, 0xc7, 0xd9, 0x7d, 0x51, 0x16, 0xbf, 0x3b, 0xe9, 0xcd,
	0x90, 0x65, 0x9c, 0x96, 0x26, 0xbd, 0xbd, 0x58, 0x3c, 0x24, 0x01, 0x64, 0x96, 0xf4, 0x5d, 0xac,
	0xe8, 0x62, 0xc2, 0xfa, 0x6f, 0xd1, 0xa7, 0xe8, 0x62, 0x12, 0xfd, 0x77, 0x80, 0x11, 0xc7, 0x2b,
	0xfc, 0xab, 0x49, 0x3b, 0xf0, 0x3c, 0x31, 0x53, 0x53, 0x66, 0x84, 0xde, 0x4d, 0x7f, 0x6d, 0x68,
	0xc3, 0xa7, 0xe3, 0xad, 0xdd, 0x59, 0x59, 0xc8, 0x98, 0xce, 0xef, 0x0d, 0x65, 0x08, 0x0d, 0x5b,
	0x4b, 0xfc, 0x5d, 0xed, 0x3b, 0x49, 0xfb, 0x7a, 0x0f, 0x97, 0x08, 0xb2, 0xff, 0xf7, 0x3c, 0x97,
	0xb7, 0xc7, 0x6c, 0x1b, 0x84, 0x62, 0x3b, 0x14, 0x8d, 0xca, 0x9e, 0x14, 0xfe, 0xbe, 0xeb, 0xc0,
	0x9d, 0x57, 0xdf, 0x76, 0x07, 0x9c, 0x8e, 0xef, 0xe4, 0x70, 0xb8, 0xbd, 0xd5, 0x28, 0x35, 0xc5,
	0xcf, 0xe5, 0x0f, 0xd1, 0x1b, 0xe0, 0x9a, 0x11, 0x1c, 0x40, 0xb8, 0x28, 0xa6, 0xf7, 0xf0, 0x4c,
	0x3d, 0xe1, 0xd3, 0x54, 0xab, 0x86, 0x90, 0x5c, 0x7c, 0xcc, 0xe1, 0x62, 0x9e, 0xe3, 0xe2, 0xc9,
	0xf0, 0x45, 0xc7, 0xcf, 0xb6, 0xef, 0x25, 0x61, 0x94, 0xba, 0xbf, 0xe7, 0x1a, 0x8d, 0x8e, 0x7b,
	0xaf, 0xf7, 0xb8, 0xfa, 0xfe, 0xa7, 0xd0, 0xee, 0x61, 0x4e, 0xab, 0x9c, 0xb2, 0x63, 0xbb, 0xb9,
	0x32, 0x9c, 0x81, 0xa7, 0x27, 0x41, 0x43, 0x89, 0xc4, 0x3b, 0x66, 0x69, 0xde, 0x65, 0x03, 0xef,
	0x6a, 0xf8, 0x3c, 0xba, 0x2c, 0x60, 0x09, 0x8a, 0xde, 0x15, 0xfa, 0x78, 0xaa, 0xa7, 0x48, 0x1f,
	0x1e, 0xdf, 0x01, 0x63, 0x0d, 0x37, 0x13, 0x1b, 0x11, 0x51, 0xc7, 0x88, 0xe8, 0x29, 0x46, 0xf6,
	0x66, 0x0f, 0xb9, 0xca, 0xf3, 0xa7, 0x22, 0x7e, 0xc6, 0x7e, 0x37, 0x03, 0x23, 0x2b, 0xcd, 0x76,
	0xab, 0x61, 0x2d, 0x4a, 0xff, 0x49, 0x70, 0xc2, 0xf2, 0xbe, 0x80, 0x8b, 0x44, 0xf6, 0x8b, 0x3b,
	0xd8, 0xb0, 0xf7, 0x94, 0xe8, 0x43, 0xf7, 0xa0, 0xa8, 0xe8, 0x0f, 0xbd, 0x36, 0xe6, 0x1c, 0xcf,
	0x7a, 0xfe, 0x88, 0x80, 0x5d, 0x69, 0x70, 0xbc, 0xda, 0x12, 0x8c, 0xb4, 0xb4, 0x9a, 0xb9, 0x63,
	0x38, 0xe1, 0x3b, 0x6f, 0x0c, 0x57, 0xca, 0x32, 0xfd, 0x4a, 0x76, 0x3e, 0x47, 0x2a, 0x64, 0x59,
	0xe2, 0x1e, 0x73, 0xe0, 0x9e, 0x9b, 0x2a, 0x88, 0xf7, 0xb5, 0x61, 0x6a, 0x6d, 0x3b, 0xfa, 0x2f,
	0x7b, 0xb2, 0x94, 0x22, 0xfd, 0xb7, 0x62, 0x34, 0x98, 0xf9, 0xd9, 0x4d, 0x40, 0x8f, 0x3b, 0x70,
	0x17, 0x38, 0xb8, 0x6f, 0x8a, 0xd0, 0xf2, 0x68, 0x90, 0x9f, 0xe9, 0x63, 0x21, 0x7a, 0x29, 0x3c,
	0x4b, 0xce, 0x29, 0xc5, 0xd5, 0xc5, 0xd2, 0x52, 0x49, 0x59, 0x2d, 0xfe, 0x5c, 0xbe, 0x58, 0x2c,
	0x14, 0x0b, 0x62, 0x9d, 0x5c, 0x7a, 0xe5, 0xac, 0xf8, 0xf9, 0x91, 0x80, 0x71, 0xd1, 0x1d, 0x09,
	0x9c, 0x04, 0xf4, 0xd6, 0xd0, 0x4e, 0xd3, 0x4e, 0xc3, 0x7b, 0xac, 0xf5, 0xbb, 0xd9, 0x4b, 0x3e,
	0x1e, 0xca, 0xfb, 0xb9, 0x57, 0x0d, 0x07, 0xc8, 0xdc, 0x0f, 0xbe, 0x18, 0xd2, 0x64, 0xe9, 0x8d,
	0x3e, 0x40, 0x62, 0xae, 0xb6, 0x1a, 0x6a, 0x0d, 0xa3, 0xed, 0x08, 0x17, 0x55, 0xac, 0x59, 0x5f,
	0xbb, 0x17, 0x55, 0xb0, 0x47, 0xe9, 0x04, 0xa4, 0xc9, 0x5f, 0xa6, 0xf1, 0x8f, 0x74, 0x5b, 0xee,
	0xcb, 0x34, 0x0b, 0xef, 0x18, 0x18, 0x68, 0x93, 0xa1, 0x56, 0x02, 0x46, 0xa6, 0x0f, 0x4e, 0xfe,
	0x34, 0x45, 0x1b, 0x85, 0xc2, 0x45, 0x98, 0x0e, 0xa2, 0x28, 0x7e, 0x3d, 0xf9, 0x17, 0x29, 0x48,
	0x57, 0x5b, 0x0d, 0xcd, 0x44, 0xbf, 0x93, 0x1c, 0x08, 0x66, 0x86, 0xda, 0xdc, 0xc0, 0x3e, 0x98,
	0xc9, 0xd6, 0x3b, 0x99, 0x66, 0x71, 0x0d, 0x99, 0xa9, 0x10, 0x86, 0x4c, 0x05, 0x5f, 0x30, 0x39,
	0x43, 0xa6, 0x74, 0x9a, 0x9d, 0x76, 0x4a, 0x77, 0x39, 0x17, 0x49, 0xbf, 0x25, 0xcd, 0xea, 0x72,
	0xd6, 0x69, 0xfa, 0x66, 0x76, 0x32, 0x08, 0x20, 0x33, 0x5b, 0x51, 0x94, 0xca, 0x92, 0x78, 0x48,
	0xca, 0x82, 0xa0, 0x54, 0x96, 0xc5, 0x84, 0x34, 0x0a, 0xe9, 0x52, 0xb9, 0x5c, 0x94, 0xc5, 0xa4,
	0xf5, 0x57, 0x29, 0x29, 0x8b, 0x45, 0x51, 0x40, 0x1f, 0x0c, 0x3d, 0xf4, 0xf2, 0x75, 0xc7, 0x29,
	0x5e, 0xe1, 0x06, 0x61, 0x7f, 0x7a, 0xe2, 0x17, 0xae, 0x7f, 0x2f, 0x40, 0x7a, 0x09, 0x1b, 0x1b,
	0x18, 0xfd, 0x62, 0x04, 0x5b, 0xe0, 0xba, 0x66, 0xb4, 0xe9, 0xc9, 0x2e, 0xd7, 0x16, 0xe8, 0x4d,
	0x93, 0xae, 0x86, 0x89, 0x36, 0xae, 0xe9, 0xcd, 0xba, 0x9d, 0x89, 0xc5, 0x0c, 0xe3, 0x12, 0xd1,
	0x23, 0x11, 0x21, 0x23, 0x84, 0x0e, 0xc4, 0xa0, 0x17, 0x05, 0x98, 0x6e, 0xb5, 0xc6, 0x0f, 0xcc,
	0xff, 0x16, 0xac, 0x8f, 0x5a, 0x17, 0xd1, 0x23, 0xa1, 0x8d, 0xb4, 0x37, 0x40, 0x86, 0x88, 0xa9,
	0x3d, 0x5f, 0xe9, 0xae, 0x8f, 0x59, 0x1e, 0x69, 0x16, 0x2e, 0x69, 0x93, 0x3b, 0xf9, 0x71, 0xdd,
	0xea, 0xba, 0x72, 0x4f, 0xa5, 0xb0, 0x37, 0x3b, 0xfa, 0x33, 0x2f, 0x80, 0x77, 0xf0, 0x00, 0x1e,
	0xef, 0xc2, 0x4a, 0xab, 0x41, 0xfe, 0xb7, 0x13, 0x59, 0xcd, 0xa8, 0x36, 0x74, 0xc7, 0xb8, 0x68,
	0x3f, 0x5b, 0xef, 0x36, 0xcd, 0xed, 0x06, 0x79, 0xc7, 0x5c, 0x58, 0xec, 0x67, 0x69, 0x06, 0xb2,
	0x6a, 0xf3, 0x22, 0x79, 0x95, 0x0a, 0x68, 0xb5, 0x9d, 0x09, 0xbd, 0xd1, 0x41, 0xfe, 0x6e, 0x0e,
	0xf9, 0xeb, 0xc3, 0x91, 0x1b, 0x3f, 0xf0, 0x7f, 0x9b, 0x81, 0xf4, 0xb2, 0xda, 0x36, 0x31, 0xfa,
	0x96, 0x10, 0x16, 0xf9, 0xe3, 0x30, 0xb9, 0xae, 0xd7, 0x76, 0xda, 0xb8, 0xce, 0x77, 0xca, 0x8e,
	0xd4, 0x41, 0x60, 0x2e, 0x9d, 0x00, 0xd1, 0x4e, 0x64, 0xc5, 0xda, 0xd6, 0xfa, 0x3d, 0xe9, 0xe4,
	0x28, 0x7b, 0x7b, 0x59, 0x35, 0xcc, 0xca, 0x3a, 0x49, 0x73, 0x8e, 0xb2, 0x7b, 0x13, 0x39, 0xe8,
	0x33, 0x01, 0xd0, 0x67, 0xfd, 0xa1, 0x1f, 0x09, 0x01, 0xbd, 0x94, 0x83, 0x91, 0x75, 0xad, 0x81,
	0xc9, 0x07, 0xa3, 0x5d, 0x82, 0xa0, 0xb1, 0xed, 0x09, 0x8b, 0xf7, 0xce, 0x98, 0x34, 0xa7, 0x35,
	0xb0, 0xec, 0x7c, 0x86, 0x16, 0xe9, 0x66, 0xbf, 0x73, 0x11, 0x42, 0xc2, 0x73, 0x11, 0x82, 0x04,
	0xa9, 0xba, 0x6a, 0xaa, 0x84, 0xf5, 0xe3, 0x32, 0xf9, 0xcf, 0xef, 0x1d, 0x09, 0x9d, 0x7b, 0x47,
	0x0f, 0x09, 0xd1, 0xf4, 0x9f, 0x4d, 0x9a, 0x4f, 0xff, 0x59, 0xb3, 0xe1, 0xa0, 0x5e, 0x60, 0xce,
	0xb3, 0x05, 0x43, 0x4d, 0x35, 0xb0, 0xb9, 0xec, 0xdd, 0x9e, 0x49, 0xcb, 0x7c, 0x22, 0xd9, 0xf1,
	0x6e, 0x57, 0xd5, 0x6d, 0x4c, 0x2a, 0xcb, 0x5b, 0xef, 0xd8, 0x1e, 0xe7, 0x9e, 0x74, 0x57, 0xdb,
	0xa6, 0x07, 0xad, 0x6d, 0xbb, 0xb5, 0x31, 0xfe, 0x4e, 0xf7, 0xe6, 0x14, 0x08, 0xf9, 0x1d, 0xf3,
	0x19, 0xad, 0x6c, 0xff, 0x39, 0xf4, 0xe6, 0x17, 0xd3, 0x5e, 0x3b, 0xe6, 0xc1, 0xea, 0xda, 0x88,
	0x52, 0x12, 0x6e, 0x93, 0xcd, 0xaf, 0x6d, 0x43, 0x39, 0xa0, 0x63, 0xfb, 0x21, 0xe8, 0xfb, 0x9f,
	0x87, 0x23, 0xaa, 0x8c, 0x3c, 0x8a, 0xc1, 0x79, 0xb6, 0x8d, 0x02, 0x29, 0xd7, 0xae, 0xf4, 0xfa,
	0xd0, 0x9e, 0x40, 0x94, 0x3f, 0x81, 0x4e, 0x01, 0xd1, 0xa6, 0x4a, 0xe1, 0x42, 0x04, 0x06, 0x54,
	0x1b, 0x3f, 0x32, 0x3f, 0xf4, 0x5a, 0x0f, 0x72, 0xfb, 0xc6, 0x86, 0x37, 0xdb, 0x07, 0x5a, 0x98,
	0x69, 0xb3, 0x7b, 0x18, 0x15, 0xa2, 0xf1, 0x3b, 0x9c, 0xfd, 0x39, 0xb0, 0xe2, 0x21, 0x1c, 0x89,
	0x12, 0x20, 0x43, 0xf7, 0x0f, 0xd0, 0xbb, 0x43, 0xab, 0x4c, 0x4b, 0xed, 0xf0, 0x0e, 0x04, 0xce,
	0x73, 0x14, 0x53, 0x02, 0xe7, 0x68, 0x90, 0x8a, 0xe4, 0x68, 0xc0, 0xfb, 0x0b, 0x87, 0xe8, 0x47,
	0xb4, 0x8d, 0x31, 0xaf, 0x12, 0xa3, 0xf4, 0xb0, 0xae, 0x04, 0xc5, 0x8f, 0xf7, 0x13, 0x29, 0x18,
	0xa7, 0x55, 0x9f, 0xd3, 0xea, 0x1b, 0xd8, 0x44, 0xff, 0xf8, 0x53, 0x84, 0xba, 0x54, 0x86, 0xf1,
	0xf3, 0x84, 0x6c, 0x1a, 0x8e, 0x9e, 0x19, 0x24, 0x82, 0xef, 0x01, 0xa2, 0xed, 0xb4, 0xc3, 0xef,
	0x73, 0xdf, 0xa3, 0x4f, 0x86, 0xde, 0x50, 0xf1, 0x82, 0xc6, 0x4a, 0x8c, 0x57, 0x96, 0xc2, 0x6d,
	0xab, 0xf4, 0x24, 0x6b, 0x08, 0x1e, 0xe8, 0x7c, 0x30, 0xc4, 0x7c, 0x04, 0x71, 0xf2, 0x9b, 0xe7,
	0x46, 0xb8, 0x1c, 0x81, 0x32, 0x60, 0xc0, 0x71, 0x12, 0xc3, 0x1d, 0x2d, 0xe9, 0x51, 0x75, 0xfc,
	0x9c, 0x7f, 0x0b, 0xbd, 0xb3, 0x62, 0x4e, 0xc3, 0x8d, 0x7a, 0x1b, 0x19, 0xfb, 0x9f, 0xca, 0x9c,
	0x84, 0xcc, 0x3a, 0x29, 0x8c, 0x89, 0xa8, 0xef, 0xe5, 0x29, 0x2c, 0x1b, 0x7a, 0x73, 0x32, 0xec,
	0x56, 0x0d, 0x33, 0x8d, 0xd9, 0xd4, 0x0e, 0x04, 0xa6, 0xb7, 0x84, 0xda, 0x2a, 0x09, 0xae, 0x39,
	0x7e, 0x94, 0xde, 0x27, 0xc0, 0x38, 0x0b, 0x42, 0x98, 0x6b, 0x68, 0x1b, 0x4d, 0xef, 0x61, 0xc7,
	0xbe, 0x7b, 0x88, 0x74, 0x13, 0xa4, 0x55, 0xab, 0x34, 0xe6, 0xa0, 0x87, 0xba, 0xaa, 0x40, 0x52,
	0x9f, 0x4c, 0x33, 0x46, 0x88, 0x2d, 0xe2, 0x0a, 0xb6, 0x4d, 0xf3, 0x10, 0x63, 0x8b, 0xf4, 0xac,
	0x3c, 0x7e, 0xc4, 0xbe, 0x2d, 0xc0, 0x11, 0x46, 0xc0, 0x59, 0x6c, 0x98, 0x5a, 0x4d, 0x6d, 0x50,
	0xe4, 0x5e, 0x91, 0x18, 0x04, 0x74, 0x0b, 0x30, 0xb1, 0xeb, 0x2d, 0x96, 0x41, 0x38, 0xdd, 0x15,
	0x42, 0x8e, 0x00, 0x99, 0xff, 0x30, 0x42, 0x8c, 0x06, 0x8e, 0xab, 0x5c, 0x99, 0x43, 0x8c, 0xd1,
	0x10, 0x9a, 0x88, 0xf8, 0x21, 0x7e, 0x4d, 0x8a, 0x86, 0x2d, 0x71, 0xd5, 0xe7, 0xd7, 0x43, 0x63,
	0xbb, 0x02, 0x63, 0x04, 0x4b, 0xfa, 0x21, 0xb3, 0x1a, 0x04, 0x08, 0xb1, 0xa3, 0x77, 0x58, 0xe0,
	0x3d, 0xe7, 0x5b, 0xd9, 0x5b, 0x0e, 0x3a, 0x07, 0xe0, 0xbe, 0xf2, 0x2a, 0xe9, 0x84, 0x9f, 0x92,
	0x4e, 0x86, 0x53, 0xd2, 0xef, 0x0a, 0x7d, 0xb4, 0xae, 0x3b, 0xd9, 0xfb, 0x17, 0x8f, 0x70, 0x87,
	0xaa, 0x7a, 0xd7, 0x1e, 0xbf, 0x5c, 0xbc, 0x31, 0xd5, 0x19, 0x26, 0xfb, 0xd3, 0x03, 0x99, 0x1f,
	0x7b, 0xf5, 0x81, 0xd0, 0xa1, 0x0f, 0xf6, 0x31, 0x1f, 0xbe, 0x0e, 0x0e, 0xd3, 0x2a, 0xf2, 0x0e,
	0x59, 0xf4, 0xf6, 0xd5, 0xce, 0x64, 0xf4, 0x99, 0x3e, 0x84, 0xa0, 0x57, 0x0c, 0xef, 0x20, 0x25,
	0x17, 0x6d, 0xb2, 0x1b, 0x55, 0x40, 0x0e, 0x2e, 0xf4, 0xf7, 0xf7, 0x52, 0x74, 0xb6, 0xbb, 0x42,
	0x62, 0x4a, 0xa2, 0x3f, 0x4f, 0x0d, 0x62, 0x44, 0xb8, 0x07, 0x52, 0xa6, 0x7d, 0x4b, 0x74, 0x77,
	0xc3, 0x84, 0x5b, 0xa5, 0x1b, 0x8d, 0x12, 0x5f, 0x30, 0x17, 0x0e, 0xc9, 0xe4, 0x4b, 0xe9, 0x04,
	0x1c, 0x5e, 0x53, 0x6b, 0x5b, 0x1b, 0x86, 0xbe, 0xd3, 0xac, 0xe7, 0xf5, 0x86, 0x6e, 0x50, 0xa3,
	0x13, 0x09, 0xeb, 0xc9, 0xbf, 0x90, 0x4e, 0xd9, 0x53, 0x87, 0x74, 0xaf, 0xa9, 0xc3, 0xc2, 0x21,
	0x36, 0x79, 0x90, 0x6e, 0x76, 0x94, 0x4e, 0x26, 0x50, 0xe9, 0x2c, 0x1c, 0xb2, 0xd5, 0x8e, 0x54,
	0x80, 0x91, 0xba, 0xb6, 0x4b, 0xf6, 0x91, 0x59, 0x98, 0xcc, 0xe0, 0xa3, 0x3a, 0x05, 0x6d, 0x97,
	0xee, 0x3a, 0x2f, 0x1c, 0x92, 0x9d, 0x2f, 0xa5, 0x79, 0x18, 0x25, 0x36, 0x7b, 0x52, 0xcc, 0x48,
	0xa4, 0x63, 0x38, 0x0b, 0x87, 0x64, 0xf7, 0x5b, 0x6b, 0xf6, 0x91, 0x22, 0x0e, 0xee, 0x77, 0xdb,
	0x7b, 0xe1, 0x89, 0x48, 0x7b, 0xe1, 0x16, 0x2f, 0xe8, 0x6e, 0xf8, 0x51, 0x48, 0xd7, 0x08, 0x87,
	0x93, 0x8c, 0xc3, 0xf4, 0x51, 0xba, 0x03, 0x52, 0xdb, 0xaa, 0x61, 0x2f, 0x81, 0x8f, 0xf7, 0x2e,
	0x77, 0x49, 0x35, 0xb6, 0x2c, 0x04, 0xad, 0xaf, 0x66, 0xb3, 0x90, 0x26, 0x8c, 0x73, 0xfe, 0xa0,
	0x27, 0xd8, 0x34, 0x24, 0xaf, 0x37, 0xad, 0x61, 0x5f, 0xd1, 0xed, 0x53, 0x00, 0xb5, 0x41, 0xc8,
	0x1c, 0xef, 0xf1, 0x2a, 0xec, 0xf1, 0x78, 0xfd, 0xb3, 0x3e, 0xe6, 0x16, 0x9d, 0x94, 0xfa, 0x2f,
	0x91, 0x1b, 0x5a, 0xd3, 0x43, 0x95, 0xfd, 0x18, 0x51, 0x6b, 0x44, 0x9d, 0x75, 0xf4, 0x20, 0x2f,
	0x7e, 0xe5, 0xf1, 0x9e, 0x14, 0x4c, 0x59, 0x84, 0x50, 0x5f, 0x70, 0x3e, 0x20, 0x2d, 0xfa, 0xfc,
	0x40, 0x26, 0x97, 0x5d, 0x46, 0x04, 0xa1, 0xeb, 0x88, 0xb0, 0xe7, 0x24, 0x50, 0xaa, 0xc7, 0x49,
	0xa0, 0x74, 0x34, 0x03, 0x1d, 0x17, 0x63, 0x74, 0x99, 0x97, 0x9f, 0xdb, 0x7c, 0x00, 0xea, 0xc6,
	0x97, 0x81, 0x4c, 0x40, 0x3e, 0xe0, 0x48, 0x4a, 0x95, 0x93, 0x94, 0xbb, 0xfb, 0x27, 0x24, 0x7e,
	0x69, 0xf9, 0x58, 0x0a, 0x9e, 0xe5, 0x12, 0x53, 0xc6, 0xe7, 0x99, 0xa0, 0x7c, 0x75, 0x20, 0x82,
	0x72, 0xb3, 0x7b, 0x8f, 0x54, 0x8f, 0xc5, 0xbe, 0x9d, 0x2f, 0x6e, 0x89, 0xf9, 0xd3, 0xd0, 0x27,
	0x18, 0x3a, 0x81, 0x72, 0x78, 0xe3, 0x23, 0x2c, 0x47, 0x21, 0x43, 0x35, 0x8c, 0x7d, 0x0b, 0x3e,
	0x7d, 0x8a, 0xa8, 0x6e, 0xc2, 0x9d, 0x7b, 0x08, 0x4b, 0xdb, 0x10, 0xe4, 0x87, 0x19, 0x1e, 0x94,
	0x1d, 0xa3, 0x59, 0x6a, 0x9a, 0x3a, 0xfa, 0x95, 0x81, 0x08, 0x8e, 0xe3, 0x4b, 0x26, 0xf4, 0xe3,
	0x4b, 0xd6, 0x97, 0x19, 0xc2, 0x6e, 0xc1, 0x81, 0x98, 0x21, 0x7c, 0x2a, 0x8f, 0x1f, 0xbf, 0xf7,
	0x0b, 0x70, 0x94, 0xad, 0x86, 0x66, 0xf9, 0x29, 0x1c, 0xba, 0x6f, 0x10, 0x40, 0x1e, 0xb1, 0xe7,
	0x31, 0xec, 0xf2, 0x6b, 0xf2, 0xc0, 0x9f, 0x31, 0x08, 0x8c, 0xca, 0xc9, 0xad, 0xd7, 0x3a, 0x28,
	0x1c, 0x08, 0x52, 0xe1, 0x82, 0x71, 0x46, 0x20, 0x23, 0x7e, 0xcc, 0x7e, 0x53, 0x80, 0x0c, 0xbb,
	0x8c, 0x62, 0x25, 0x16, 0x07, 0x04, 0x3e, 0x02, 0x53, 0x88, 0x8d, 0xaf, 0xc8, 0xb7, 0x40, 0xc4,
	0xb7, 0xe5, 0x75, 0x30, 0xd7, 0x3c, 0xa0, 0x47, 0x04, 0x66, 0x59, 0x59, 0x54, 0x4d, 0x7c, 0x01,
	0xfd, 0xba, 0x00, 0xd9, 0x2a, 0x36, 0x2d, 0xcd, 0x14, 0x1e, 0x23, 0x7f, 0x9b, 0xb9, 0xe4, 0x59,
	0xbb, 0x8d, 0xd2, 0xd5, 0x58, 0x54, 0x1d, 0x47, 0xe8, 0x9a, 0x61, 0x34, 0x0d, 0x5b, 0xc7, 0x05,
	0x55, 0x3e, 0x84, 0xf3, 0xce, 0x57, 0xc3, 0x28, 0x21, 0x83, 0xc0, 0xf1, 0x59, 0x0f, 0x34, 0xaf,
	0x4e, 0xc4, 0x82, 0x8d, 0x35, 0x7c, 0x91, 0xab, 0x12, 0xc8, 0xec, 0x65, 0x2c, 0xcc, 0xf0, 0x65,
	0x2d, 0xd3, 0xda, 0x32, 0xfd, 0x2a, 0xc2, 0x15, 0x5e, 0x4e, 0xb3, 0x06, 0x8a, 0x6c, 0xb8, 0xbb,
	0x55, 0x7a, 0xd5, 0x3d, 0x84, 0x9b, 0x79, 0x04, 0x18, 0xa9, 0x5a, 0xcb, 0x0d, 0x6b, 0x4c, 0x39,
	0xb7, 0x7f, 0x28, 0xbb, 0x0f, 0x56, 0x11, 0x3b, 0x9a, 0xcd, 0x91, 0xc1, 0x0d, 0x51, 0x11, 0x3a,
	0x5a, 0x50, 0xe5, 0xf1, 0xe3, 0xf1, 0x41, 0x8a, 0x07, 0x91, 0x65, 0xf4, 0x76, 0x01, 0x84, 0x79,
	0x6c, 0x0e, 0xe8, 0xe4, 0x48, 0xd8, 0x53, 0x08, 0xfc, 0xd0, 0x15, 0x18, 0x2c, 0x80, 0x63, 0x18,
	0xa1, 0x79, 0x66, 0x1e, 0x0f, 0xa6, 0x03, 0x85, 0x8b, 0x12, 0x10, 0x8a, 0x80, 0xf8, 0x51, 0xfb,
	0x08, 0x45, 0x8d, 0x5a, 0xb0, 0x7e, 0x79, 0x00, 0x1a, 0x71, 0xb8, 0x93, 0x77, 0x9b, 0x81, 0xa4,
	0x8c, 0x83, 0xea, 0x6f, 0xdd, 0x2a, 0x1f, 0x8a, 0x8f, 0x21, 0x58, 0x9d, 0x7d, 0x13, 0xd7, 0xb6,
	0x70, 0x1d, 0xfd, 0xfc, 0xfe, 0xa1, 0x9b, 0x82, 0x6c, 0x8d, 0x96, 0x46, 0xc0, 0x1b, 0x91, 0xed,
	0xc7, 0x08, 0x17, 0xe8, 0xf3, 0x8a, 0x88, 0x7e, 0x3e, 0xc4, 0x0b, 0xf4, 0x43, 0x54, 0x1f, 0x3f,
	0x32, 0xbf, 0x4f, 0x27, 0x19, 0xa5, 0x9a, 0xde, 0x44, 0xff, 0x76, 0xff, 0xb0, 0x5c, 0x0e, 0xa3,
	0x5a, 0x4d, 0x6f, 0x96, 0xb6, 0xd5, 0x0d, 0xdb, 0x8c, 0xea, 0x26, 0xd8, 0x6f, 0x8b, 0xdb, 0xfa,
	0xfd, 0x1a, 0xdb, 0x9a, 0x71, 0x13, 0xfa, 0x9d, 0x4c, 0x58, 0xa4, 0x1f, 0xd4, 0x64, 0xa2, 0x4b,
	0xdd, 0xf1, 0x43, 0xf6, 0x19, 0xd7, 0x85, 0x82, 0xaa, 0xc2, 0x67, 0x84, 0x25, 0xa3, 0x9f, 0xe1,
	0xcc, 0xdb, 0x8a, 0x03, 0x19, 0xce, 0x02, 0x08, 0x88, 0x1f, 0xc7, 0xd7, 0xbb, 0x38, 0xc6, 0x6e,
	0xc7, 0xd8, 0x07, 0x3a, 0x83, 0x9b, 0x1e, 0xf6, 0x89, 0xce, 0xc1, 0x4c, 0x11, 0x3f, 0xce, 0x82,
	0x4d, 0xb1, 0x19, 0x0f, 0xfa, 0xa5, 0x41, 0x80, 0x73, 0x5b, 0x3f, 0x9b, 0x62, 0x74, 0x4b, 0x2c,
	0xc2, 0x5d, 0x3c, 0x7b, 0x38, 0x68, 0x95, 0x32, 0x10, 0x04, 0xc3, 0xdd, 0xc5, 0x13, 0xa6, 0xfe,
	0xf8, 0x01, 0x7c, 0xb9, 0x00, 0x93, 0x64, 0x9f, 0xab, 0x81, 0x55, 0x83, 0x2a, 0xca, 0x81, 0x78,
	0x63, 0x7e, 0x30, 0x74, 0x98, 0x7c, 0x9e, 0x0f, 0x2e, 0x1d, 0x03, 0x81, 0x22, 0xdc, 0xb5, 0xbf,
	0x21, 0x49, 0x18, 0x8a, 0x29, 0x50, 0x74, 0x48, 0x60, 0x22, 0x3e, 0x18, 0x3c, 0x22, 0xba, 0x7d,
	0xf1, 0xcc, 0xb0, 0x3b, 0xdb, 0x90, 0xdd, 0xbe, 0xc2, 0x10, 0x31, 0x84, 0x60, 0xec, 0x37, 0x31,
	0x53, 0xa0, 0x42, 0xae, 0xaa, 0x7a, 0x34, 0xe5, 0x1c, 0x7e, 0xf8, 0xd2, 0x40, 0xdc, 0x7c, 0xf6,
	0x11, 0x39, 0x51, 0x82, 0x94, 0xa1, 0x9f, 0xa7, 0x66, 0xa9, 0x09, 0x99, 0xfc, 0x27, 0x53, 0x7e,
	0xbd, 0xb1, 0xb3, 0xdd, 0xa4, 0x57, 0x99, 0x4e, 0xc8, 0xf6, 0xa3, 0x74, 0x35, 0x4c, 0x9c, 0xd7,
	0xcc, 0xcd, 0x05, 0xac, 0xd6, 0xb1, 0x21, 0xeb, 0xe7, 0xd9, 0xad, 0xc1, 0x7c, 0x22, 0xbf, 0x07,
	0x1b, 0x62, 0x7e, 0x49, 0xee, 0xaf, 0x1a, 0xca, 0x49, 0x89, 0x28, 0x33, 0x4f, 0x7f, 0xaa, 0xe2,
	0x17, 0x98, 0x8f, 0x0a, 0x30, 0x2a, 0xeb, 0xe7, 0x99, 0x90, 0xfc, 0xbb, 0x83, 0x95, 0x91, 0xc8,
	0x0b, 0x3d, 0x7a, 0x1f, 0x99, 0x4d, 0xfe, 0xd0, 0x17, 0x7a, 0x81, 0xd5, 0x0f, 0xc5, 0x3d, 0x7e,
	0x5c, 0xd6, 0xcf, 0x57, 0xb1, 0x49, 0x7b, 0x04, 0x5a, 0x1d, 0x90, 0x27, 0x9f, 0xd6, 0xa6, 0x05,
	0xb2, 0x75, 0xb8, 0xf3, 0x8c, 0xde, 0x1f, 0xfa, 0x9a, 0x27, 0x9e, 0x41, 0x0e, 0x89, 0x03, 0x81,
	0xe8, 0x3d, 0xa1, 0x6e, 0x77, 0x0a, 0x47, 0x41, 0xfc, 0x28, 0xfd, 0x9a, 0x00, 0x63, 0xb2, 0x7e,
	0xde, 0x1a, 0x1a, 0xe6, 0xb4, 0x46, 0x63, 0x30, 0x23, 0x64, 0xd4, 0xc9, 0xbf, 0xcd, 0x06, 0x9b,
	0x8a, 0xa1, 0x4f, 0xfe, 0x7b, 0x10, 0x10, 0x3f, 0x0c, 0x0f, 0xd1, 0xce, 0x62, 0x8f, 0xd0, 0xcd,
	0xc1, 0xe0, 0xd0, 0x6f, 0x87, 0x70, 0xc8, 0x38, 0xb0, 0x0e, 0xe1, 0x47, 0xc1, 0x50, 0x76, 0x4e,
	0x26, 0xf3, 0x64, 0x98, 0x1f, 0x6c, 0x9f, 0xf8, 0x70, 0x34, 0xf7, 0x1a, 0x36, 0xec, 0x72, 0x84,
	0x0c, 0x04, 0x8d, 0x08, 0x6e, 0x34, 0x21, 0x68, 0x88, 0x1f, 0x8f, 0x3f, 0x12, 0x60, 0x9c, 0x92,
	0xf0, 0x0c, 0x99, 0x05, 0xf4, 0xd5, 0xa9, 0xbc, 0x2d, 0x38, 0x98, 0x4e, 0x15, 0x40, 0x41, 0xfc,
	0x20, 0xfe, 0xdf, 0x24, 0x99, 0xc7, 0xf5, 0x71, 0x46, 0xd1, 0x0f, 0xc1, 0xbe, 0x27, 0x63, 0x03,
	0x3c, 0xa7, 0xd8, 0xcf, 0x64, 0xec, 0x80, 0xce, 0x2a, 0x3e, 0xe4, 0xf4, 0xa2, 0x41, 0x62, 0xb0,
	0x8f, 0xae, 0x30, 0x40, 0x18, 0xfa, 0xec, 0x0a, 0x07, 0x84, 0xc4, 0x5f, 0x09, 0x00, 0x94, 0x80,
	0x25, 0x7d, 0x17, 0xa3, 0xc7, 0x06, 0xb2, 0xf0, 0xed, 0x74, 0x0d, 0x15, 0x7a, 0xb8, 0x86, 0x46,
	0x3c, 0xed, 0x1f, 0xd5, 0x12, 0xe8, 0xe1, 0xf2, 0x92, 0xef, 0x35, 0x9b, 0x31, 0x5a, 0x02, 0x83,
	0xeb, 0x8f, 0x1f, 0xe3, 0x6f, 0xd2, 0xd9, 0x9c, 0x7b, 0x8a, 0xe9, 0x75, 0x03, 0x41, 0xd9, 0xb3,
	0xfa, 0x17, 0xf8, 0xd5, 0xff, 0x3e, 0xb0, 0xed, 0x77, 0x8e, 0xd8, 0xeb, 0x74, 0x52, 0xfc, 0x73,
	0xc4, 0x83, 0x3b, 0x85, 0xf4, 0xcb, 0x29, 0x38, 0xcc, 0x94, 0xc8, 0x4f, 0x03, 0xc4, 0x11, 0xcf,
	0x92, 0x70, 0x4a, 0xb2, 0x07, 0xca, 0x83, 0x32, 0x48, 0x45, 0x31, 0x65, 0x86, 0x20, 0x6f, 0x28,
	0xd6, 0x8d, 0x4c, 0xf1, 0x42, 0x4b, 0x6d, 0xd6, 0xc3, 0x07, 0x7c, 0xec, 0x01, 0xbc, 0x6d, 0x6b,
	0x14, 0x78, 0x5b, 0x63, 0x17, 0xcb, 0x64, 0xe4, 0x9d, 0x6b, 0xc2, 0x32, 0x4a, 0xee, 0xd0, 0x77,
	0xae, 0xfd, 0xeb, 0x8e, 0x1f, 0xa5, 0x0f, 0x0b, 0x90, 0xaa, 0xea, 0x86, 0x89, 0x1e, 0x8e, 0xd2,
	0x3b, 0x29, 0xe7, 0x5d, 0x90, 0xec, 0x67, 0x29, 0xcf, 0x5d, 0x7d, 0x75, 0x32, 0xf8, 0x3c, 0x9d,
	0x6a, 0xaa, 0x24, 0x1c, 0xb8, 0x55, 0xbf, 0xe7, 0x0e, 0xac, 0xa8, 0x41, 0x1b, 0x28, 0xff, 0xaa,
	0xfe, 0x4e, 0xc4, 0xb1, 0x05, 0x6d, 0xf0, 0xad, 0x79, 0x08, 0x76, 0xdf, 0x31, 0xe6, 0x97, 0x4a,
	0x6e, 0x04, 0x7c, 0x98, 0xba, 0x8c, 0x94, 0xd5, 0x6d, 0x3c, 0x20, 0x97, 0x61, 0x12, 0x73, 0x50,
	0x70, 0x63, 0x0e, 0x46, 0xed, 0x50, 0xf4, 0x94, 0x23, 0x25, 0x69, 0xd8, 0x1d, 0x2a, 0xa0, 0xee,
	0xf8, 0x81, 0xf9, 0x86, 0x35, 0xf2, 0x91, 0x35, 0x64, 0xae, 0x59, 0x67, 0x41, 0xdc, 0xfe, 0xf6,
	0xa0, 0xf7, 0x6e, 0xf6, 0x84, 0x79, 0xe3, 0xc3, 0x45, 0xa6, 0x3b, 0x6f, 0xb0, 0x9b, 0xa5, 0x21,
	0xe3, 0xc8, 0xc9, 0xcb, 0x4c, 0xa4, 0x5b, 0xec, 0x9c, 0xef, 0xd0, 0x13, 0xd1, 0xcc, 0x39, 0xa4,
	0x88, 0x0e, 0xc6, 0xc5, 0x3c, 0xa4, 0x46, 0x30, 0xf4, 0x84, 0xa0, 0xee, 0x5f, 0x86, 0x97, 0xd1,
	0xde, 0x4b, 0x04, 0x23, 0x9a, 0xb2, 0x9d, 0xab, 0x1f, 0x0f, 0xca, 0xcb, 0xa8, 0x17, 0x01, 0x43,
	0x08, 0x71, 0x96, 0x66, 0x9b, 0xbc, 0xc4, 0x05, 0x0f, 0x3d, 0x99, 0x8c, 0x5d, 0x79, 0x87, 0xbf,
	0x36, 0xd7, 0xa5, 0x2b, 0x58, 0x7b, 0x47, 0x71, 0x74, 0x0d, 0x2a, 0x6e, 0x08, 0xe6, 0x84, 0x24,
	0x71, 0x51, 0x3e, 0xa7, 0xd5, 0xcd, 0xcd, 0x01, 0x39, 0xfa, 0x9f, 0xb7, 0xca, 0xb2, 0xef, 0x9f,
	0x23, 0x0f, 0xe8, 0xe9, 0x44, 0xa4, 0xf0, 0x15, 0x0e, 0x4b, 0x08, 0x59, 0x3e, 0x2c, 0x8e, 0x10,
	0x74, 0x22, 0xb0, 0xbc, 0x21, 0x4a, 0xf4, 0x59, 0xad, 0x8e, 0xf5, 0x67, 0xa0, 0x44, 0x13, 0xba,
	0x06, 0x27, 0xd1, 0x41, 0xc5, 0xfd, 0x0b, 0x95, 0x68, 0x87, 0x25, 0x03, 0x92, 0xe8, 0xc0, 0xf2,
	0x86, 0x10, 0x1b, 0x1d, 0xd8, 0xfc, 0x7a, 0x51, 0x6b, 0x6e, 0xa1, 0xcf, 0xa5, 0xed, 0x9b, 0xef,
	0xce, 0x69, 0xe6, 0x26, 0x3b, 0xe6, 0xfe, 0x99, 0xd0, 0x77, 0x64, 0xf4, 0x71, 0x94, 0xfd, 0x18,
	0x80, 0xc9, 0x6e, 0xa4, 0x72, 0x62, 0xe6, 0x78, 0x52, 0xa4, 0x1c, 0x4c, 0x68, 0x4d, 0x13, 0x1b,
	0x4d, 0xb5, 0x31, 0xd7, 0x50, 0x37, 0xda, 0x53, 0x59, 0x72, 0x34, 0xf3, 0xb2, 0x8e, 0xc1, 0xbb,
	0xe4, 0xc9, 0x23, 0xf3, 0x5f, 0x84, 0x9e, 0x6b, 0x46, 0x0c, 0xf9, 0x73, 0x32, 0x64, 0x24, 0x16,
	0x27, 0xfc, 0xd3, 0x0f, 0xa2, 0x19, 0x5f, 0x2c, 0x40, 0x66, 0x3a, 0xc1, 0x88, 0x3c, 0x53, 0xf4,
	0x36, 0x5e, 0xe8, 0x68, 0xbc, 0x33, 0xf5, 0x48, 0x0d, 0xd8, 0x30, 0x13, 0x86, 0xf4, 0x21, 0x9c,
	0xfc, 0x48, 0xc3, 0x25, 0x76, 0xf8, 0xba, 0x56, 0x0b, 0xab, 0x86, 0xda, 0xac, 0xe1, 0x08, 0xd2,
	0x1c, 0x34, 0x97, 0x9c, 0x83, 0x11, 0xad, 0xa6, 0x37, 0xab, 0xda, 0x4b, 0xec, 0xab, 0x5c, 0x82,
	0x63, 0x9f, 0x12, 0x8e, 0x94, 0xd8, 0x17, 0xb2, 0xf3, 0xad, 0x54, 0x82, 0xd1, 0x9a, 0x6a, 0xd4,
	0xab, 0x9e, 0xcb, 0xad, 0xaf, 0xef, 0x5d, 0x50, 0xde, 0xfe, 0x44, 0x76, 0xbf, 0x96, 0x2a, 0x3c,
	0x13, 0x33, 0x1d, 0xa7, 0x7f, 0x7d, 0x0b, 0x2b, 0xb8, 0x1f, 0x71, 0x3c, 0xb7, 0xb8, 0x63, 0xe0,
	0x06, 0xb9, 0x39, 0x93, 0x76, 0xbb, 0x51, 0xd9, 0x4d, 0x40, 0x1f, 0xf5, 0x4a, 0xf3, 0x12, 0x2f,
	0xcd, 0x2f, 0xf2, 0x11, 0x89, 0x3d, 0x68, 0x0c, 0x64, 0x4e, 0xfc, 0x3e, 0x47, 0x30, 0x97, 0x39,
	0xc1, 0xbc, 0xa3, 0x4f, 0x2a, 0xe2, 0x97, 0xcc, 0x0f, 0x64, 0x60, 0x82, 0x1e, 0x26, 0x67, 0xec,
	0x44, 0x2f, 0x27, 0x97, 0xb5, 0x99, 0x67, 0xf0, 0x45, 0x54, 0xdd, 0xff, 0x40, 0x27, 0x82, 0xb0,
	0x85, 0x2f, 0xb2, 0xfe, 0x6e, 0xfd, 0x8d, 0xba, 0x47, 0x6a, 0xd3, 0x35, 0x43, 0x69, 0x1a, 0xf6,
	0x1e, 0x69, 0x70, 0xf5, 0xf1, 0xe3, 0xf3, 0x5b, 0x02, 0x08, 0xb9, 0x7a, 0x3d, 0x7c, 0x7c, 0x27,
	0x7f, 0x28, 0xae, 0x84, 0x31, 0xbb, 0xcf, 0x9c, 0x71, 0x20, 0xf1, 0x26, 0x45, 0x35, 0x38, 0x39,
	0xbc, 0xc9, 0xd5, 0x87, 0x6e, 0xc1, 0x0d, 0xa8, 0x3b, 0x7e, 0x50, 0x5e, 0x97, 0x65, 0x9d, 0x66,
	0x56, 0xd7, 0xb7, 0xc8, 0xb1, 0x84, 0x87, 0x05, 0x48, 0xcf, 0x61, 0xb3, 0xb6, 0x39, 0xa0, 0x3e,
	0xb3, 0x63, 0x34, 0xec, 0x3e, 0xb3, 0xe7, 0xe6, 0xc9, 0xde, 0x13, 0x43, 0x9b, 0xac, 0x19, 0x42,
	0xd2, 0xb0, 0xc3, 0x35, 0x06, 0xd6, 0x1e, 0x3f, 0x38, 0x4f, 0x0b, 0x30, 0xe9, 0x98, 0x8d, 0x28,
	0x26, 0xbf, 0xf1, 0x8c, 0x33, 0x06, 0xa2, 0xaf, 0x46, 0x0b, 0xa9, 0xe2, 0xf0, 0x94, 0x6f, 0x59,
	0xcc, 0xd6, 0xba, 0x08, 0xc1, 0x56, 0xc2, 0x11, 0x38, 0x84, 0x65, 0xb1, 0x00, 0x23, 0x84, 0xa0,
	0x82, 0xb6, 0x4b, 0xdc, 0xb4, 0x38, 0xeb, 0xdd, 0x03, 0x03, 0xb1, 0xde, 0xdd, 0xc1, 0x5b, 0xef,
	0x42, 0x86, 0x30, 0xb4, 0x8d, 0x77, 0x11, 0xfd, 0x16, 0xac, 0xef, 0x07, 0x6e, 0xbb, 0x8b, 0xe0,
	0xb7, 0xd0, 0xa3, 0xfe, 0x21, 0x5c, 0xd1, 0x7b, 0x82, 0x29, 0x5b, 0x7b, 0xf3, 0x0a, 0x3d, 0x20,
	0x41, 0xea, 0xac, 0xf5, 0xe7, 0x49, 0xf7, 0xa2, 0x8a, 0x07, 0x06, 0x70, 0x10, 0xfe, 0x2e, 0x48,
	0x91, 0xcb, 0x78, 0x53, 0x1d, 0x21, 0x37, 0x03, 0x77, 0xd2, 0x2c, 0x42, 0x64, 0xf2, 0x5d, 0xd4,
	0x60, 0x65, 0x5c, 0x11, 0x33, 0x83, 0x73, 0xc3, 0x93, 0x8e, 0x42, 0xc6, 0x2a, 0xd7, 0x59, 0x66,
	0xb1, 0xa7, 0x28, 0xc6, 0xf7, 0x10, 0xb4, 0xc5, 0x8f, 0xfc, 0x93, 0xe4, 0x4e, 0x1e, 0x12, 0x53,
	0xf5, 0x91, 0x01, 0xc0, 0xeb, 0xc3, 0x96, 0x7d, 0xc3, 0xfe, 0xe1, 0xfd, 0xc0, 0xee, 0x04, 0x70,
	0x1d, 0xaa, 0x13, 0x6d, 0x08, 0x1a, 0x86, 0x72, 0xf2, 0x37, 0xc3, 0x1c, 0xff, 0xee, 0x1b, 0x24,
	0xba, 0x29, 0x4e, 0xe8, 0xf7, 0x85, 0xce, 0x00, 0x1d, 0x02, 0xfb, 0x46, 0xe7, 0x80, 0x5c, 0x02,
	0xff, 0x58, 0x80, 0xb1, 0xaa, 0x7b, 0x81, 0x5c, 0xf8, 0x1b, 0x0a, 0x22, 0x43, 0x64, 0x8d, 0xb5,
	0x5c, 0x7c, 0xc8, 0x89, 0xfe, 0x43, 0x86, 0xf2, 0xac, 0xf3, 0xd0, 0x3f, 0xec, 0x90, 0xa1, 0x61,
	0x09, 0x89, 0x1f, 0xc8, 0x2f, 0xd3, 0x1b, 0x41, 0x72, 0x35, 0x53, 0xdb, 0xc5, 0xe8, 0xa1, 0x18,
	0x15, 0xe9, 0x51, 0xc8, 0xe8, 0xeb, 0xeb, 0x6d, 0x76, 0xb3, 0xe0, 0x84, 0xcc, 0x9e, 0xdc, 0x2b,
	0xdd, 0x29, 0xb8, 0xec, 0x4a, 0xf7, 0x88, 0x41, 0x05, 0xf7, 0x30, 0x94, 0x36, 0x68, 0xd8, 0x41,
	0x05, 0xc3, 0x91, 0x31, 0x84, 0xb0, 0xc1, 0x60, 0x71, 0x8f, 0x99, 0x6c, 0xde, 0xce, 0x8c, 0x04,
	0x78, 0xff, 0xd8, 0x4e, 0xc3, 0xb8, 0xc7, 0x22, 0x60, 0x07, 0xa6, 0xe7, 0xd2, 0xa2, 0x9e, 0x35,
	0x76, 0x58, 0x36, 0x70, 0x7b, 0x41, 0x04, 0x3b, 0x70, 0x18, 0x22, 0x86, 0x72, 0xef, 0x8b, 0x3d,
	0xe4, 0x0d, 0x09, 0xab, 0x8f, 0x79, 0xb1, 0xaa, 0xf0, 0x58, 0x9d, 0x0e, 0xc3, 0xa6, 0x70, 0x43,
	0x60, 0xa8, 0xe5, 0xe4, 0xfb, 0x1d, 0xb8, 0x64, 0x0e, 0xae, 0xbb, 0xfa, 0xa6, 0x23, 0x7e, 0xc4,
	0x3e, 0x25, 0xd0, 0xcb, 0x1f, 0x72, 0xbb, 0xaa, 0xd6, 0x20, 0x07, 0xc4, 0x07, 0x70, 0x05, 0xe1,
	0xff, 0xf4, 0x82, 0x72, 0x96, 0x07, 0xe5, 0x9e, 0x30, 0xcc, 0xe0, 0x28, 0xf2, 0xc1, 0xe6, 0x05,
	0x5e, 0x9b, 0x39, 0x8d, 0x22, 0x7a, 0x69, 0x67, 0x24, 0x36, 0xf6, 0xde, 0x6b, 0x4c, 0xff, 0x92,
	0x03, 0xd2, 0x7d, 0x1c, 0x48, 0xc5, 0xfd, 0xd2, 0x15, 0x0d, 0xab, 0xc5, 0xe8, 0x58, 0x49, 0x53,
	0x70, 0xa4, 0x5c, 0x51, 0x56, 0x73, 0xab, 0x85, 0x9c, 0x92, 0x3b, 0x5b, 0x2a, 0x9e, 0x5b, 0x9d,
	0x5d, 0xac, 0xe4, 0xcf, 0x88, 0x02, 0xfa, 0x1d, 0x3a, 0x06, 0x56, 0xf5, 0x1d, 0xa3, 0x36, 0xa8,
	0xd9, 0x66, 0x9b, 0x14, 0xc6, 0x3a, 0x1d, 0x7b, 0x8a, 0xea, 0xb8, 0xee, 0xfa, 0x63, 0xda, 0xc4,
	0xf5, 0xea, 0x68, 0xa9, 0x01, 0x3b, 0xae, 0xf7, 0xa4, 0x20, 0xfe, 0x2e, 0xf6, 0x23, 0x01, 0x60,
	0xde, 0xd0, 0x77, 0x5a, 0x15, 0xa3, 0x8e, 0x0d, 0xf4, 0x94, 0xbb, 0xea, 0xfb, 0xed, 0x01, 0x4c,
	0x56, 0x96, 0x01, 0x36, 0x9c, 0xc2, 0x99, 0x9e, 0xba, 0x29, 0xdc, 0x1a, 0xcf, 0x25, 0x4a, 0xf6,
	0x94, 0xc1, 0x5f, 0x10, 0xf8, 0xb3, 0x3c, 0xc6, 0x41, 0x23, 0x8f, 0x5b, 0xdc, 0x20, 0x57, 0x7d,
	0x1f, 0x74, 0xb0, 0x56, 0x38, 0xac, 0xef, 0xd9, 0x07, 0x25, 0xf1, 0x63, 0xfe, 0x63, 0x01, 0xc6,
	0xe8, 0x5e, 0x2c, 0xe5, 0xe9, 0xdf, 0xb8, 0xa0, 0xbf, 0x6e, 0x00, 0xa0, 0xaf, 0xc0, 0xb8, 0xee,
	0x96, 0x4e, 0x47, 0x46, 0xaf, 0x75, 0x2d, 0x10, 0x76, 0x0f, 0x5d, 0x32, 0x57, 0x0c, 0xfa, 0x94,
	0x17, 0x79, 0x99, 0x47, 0xfe, 0x8e, 0x00, 0x7e, 0x7b, 0x4a, 0x1c, 0x24, 0xf4, 0x1f, 0x72, 0xa0,
	0x5f, 0xe1, 0xa0, 0xcf, 0xed, 0x87, 0x94, 0xf8, 0xb1, 0x7f, 0xd0, 0x31, 0xd0, 0x3b, 0xdb, 0x27,
	0xb1, 0x6c, 0x9a, 0xbc, 0xa1, 0xcf, 0x05, 0x06, 0x4f, 0x9b, 0x0f, 0x52, 0x93, 0x90, 0xd4, 0x6c,
	0x1a, 0x92, 0x5a, 0xbd, 0xaf, 0x25, 0x44, 0x60, 0x45, 0xf1, 0xe3, 0xf0, 0xd6, 0xe7, 0x40, 0xba,
	0x80, 0xd7, 0x76, 0x36, 0xd0, 0xbb, 0x04, 0xc8, 0x36, 0xf4, 0x8d, 0x52, 0x73, 0x5d, 0x67, 0x0d,
	0x4b, 0xd8, 0x0d, 0x93, 0x24, 0x48, 0x6d, 0x62, 0xd5, 0x6e, 0x2a, 0xf9, 0x2f, 0x1d, 0x87, 0x49,
	0xeb, 0xd7, 0xbe, 0xa0, 0xd8, 0x89, 0x3e, 0xd9, 0x91, 0x6a, 0x4d, 0x50, 0x4d, 0xdd, 0x54, 0x1b,
	0x32, 0xae, 0xe9, 0x46, 0x9d, 0x9e, 0x16, 0x49, 0xcb, 0x5c, 0x9a, 0x85, 0x37, 0x79, 0x26, 0xfe,
	0x0b, 0x69, 0x92, 0xc1, 0x4d, 0x90, 0xae, 0x86, 0x89, 0x75, 0xcd, 0x68, 0x9b, 0x34, 0xb7, 0x42,
	0x1d, 0x5c, 0xd2, 0x32, 0x9f, 0x68, 0xd1, 0xe3, 0x49, 0x38, 0x8b, 0x0d, 0x72, 0xb9, 0x50, 0x5a,
	0xee, 0x48, 0xb5, 0xe8, 0x69, 0xa8, 0x9e, 0xc2, 0x46, 0x28, 0x3d, 0xde, 0x34, 0xab, 0x46, 0xf7,
	0xd9, 0x2a, 0x6a, 0x94, 0xd6, 0xc8, 0x25, 0x5a, 0x35, 0x5a, 0x09, 0xcb, 0x3b, 0x8d, 0x46, 0x15,
	0xd7, 0x72, 0x1b, 0xfa, 0x14, 0xd0, 0x1a, 0xf9, 0x54, 0x09, 0xc1, 0xc8, 0x4e, 0xab, 0x6a, 0xaa,
	0xe6, 0x4e, 0x7b, 0x6a, 0x8c, 0xee, 0x27, 0xd9, 0xcf, 0xd2, 0x31, 0x80, 0xba, 0x7e, 0xbe, 0xc9,
	0xde, 0x8e, 0x53, 0x7f, 0x23, 0x37, 0xc5, 0x5a, 0x36, 0x53, 0x91, 0x9d, 0xa0, 0x31, 0xec, 0xa8,
	0x3f, 0xd7, 0x57, 0x04, 0x00, 0x73, 0xd3, 0xc0, 0x6a, 0xbd, 0x2b, 0x5c, 0x2f, 0x84, 0xa3, 0x0d,
	0x7d, 0xa3, 0x7d, 0x4e, 0x33, 0x37, 0x5d, 0x20, 0x16, 0x6c, 0x00, 0xd3, 0xb2, 0xcf, 0x5b, 0xe9,
	0x1e, 0xb8, 0xcc, 0x7e, 0x73, 0x6e, 0x53, 0x6f, 0x60, 0xc5, 0xc0, 0xb8, 0x03, 0xdf, 0xb4, 0x1c,
	0x94, 0x45, 0x9a, 0x81, 0x94, 0xf5, 0x9a, 0x5d, 0x1e, 0x8f, 0x38, 0xb9, 0x27, 0x62, 0x36, 0xc3,
	0x44, 0x4c, 0x26, 0xf9, 0xa4, 0x5b, 0xe1, 0x52, 0xfd, 0x7c, 0x73, 0x51, 0xdf, 0x58, 0x50, 0xdb,
	0x79, 0x75, 0x1d, 0xcb, 0x98, 0x1e, 0x9b, 0xd2, 0x0d, 0x22, 0x06, 0x23, 0xb2, 0xdf, 0x6b, 0x69,
	0x06, 0xa4, 0x9a, 0xba, 0x8e, 0x17, 0x79, 0x00, 0xa8, 0x64, 0x74, 0x79, 0x63, 0xc1, 0x6e, 0xa5,
	0xae, 0xd8, 0x40, 0x64, 0xe9, 0x41, 0x54, 0x6f, 0x9a, 0x05, 0xa8, 0xf5, 0x5c, 0x70, 0x01, 0x19,
	0x21, 0xb9, 0x3a, 0x52, 0xf7, 0x88, 0xf4, 0x68, 0x2f, 0x91, 0x86, 0x4e, 0x91, 0x76, 0x60, 0x1d,
	0xf3, 0xc2, 0xfa, 0xf5, 0x34, 0xa4, 0xaa, 0x17, 0x9b, 0x35, 0xf4, 0x16, 0xcf, 0xf0, 0x77, 0x0a,
	0x8e, 0x18, 0xb4, 0x4c, 0xc5, 0x50, 0x77, 0xb1, 0xd1, 0xc6, 0x8b, 0xc4, 0x8e, 0x92, 0x20, 0x65,
	0x76, 0x7d, 0x67, 0xc9, 0x6f, 0x7b, 0x4b, 0x6b, 0x15, 0xb7, 0x5b, 0xe6, 0xc5, 0x45, 0x0b, 0x8f,
	0x24, 0x8d, 0x02, 0xc5, 0x25, 0x4a, 0x77, 0x01, 0x32, 0x8d, 0x8b, 0x8a, 0x6e, 0xe3, 0x27, 0xe3,
	0x6d, 0xdd, 0xc4, 0x76, 0xa3, 0x68, 0x6f, 0x0e, 0xc8, 0x81, 0xde, 0x99, 0xf2, 0xe8, 0xd6, 0x3b,
	0x78, 0xdd, 0x7a, 0xbc, 0x0b, 0xf4, 0x56, 0xd3, 0x7c, 0x34, 0xe9, 0x8b, 0x20, 0x4b, 0xe5, 0xd9,
	0x5e, 0xa5, 0x5c, 0xd1, 0xe5, 0x7b, 0x57, 0xe2, 0x65, 0x3b, 0xb7, 0xd5, 0xb7, 0xea, 0x78, 0x57,
	0xab, 0x61, 0xd7, 0x9f, 0xcc, 0x7e, 0x76, 0x60, 0x52, 0x58, 0xc9, 0x5e, 0xcd, 0xc3, 0xd2, 0x08,
	0x0f, 0xe8, 0x5f, 0x4b, 0xa4, 0xf5, 0x1d, 0xd3, 0x12, 0xb1, 0x52, 0xb3, 0x42, 0xa4, 0x8e, 0xa9,
	0xa2, 0x80, 0x1c, 0xd2, 0x2c, 0x5c, 0xce, 0xbf, 0x5d, 0xe0, 0x75, 0x22, 0x15, 0xc8, 0xc0, 0x3c,
	0x7b, 0xc4, 0x29, 0xdb, 0x4b, 0x9c, 0x46, 0x3a, 0xc4, 0x09, 0xbd, 0xd1, 0x19, 0x78, 0xee, 0xe6,
	0x06, 0x9e, 0xeb, 0xc3, 0xa1, 0x30, 0x94, 0x70, 0x59, 0x19, 0xca, 0x72, 0xf4, 0x72, 0x8f, 0x6c,
	0x23, 0x18, 0x61, 0xa0, 0xda, 0xea, 0xcb, 0x79, 0x1e, 0x92, 0x0c, 0xbf, 0x29, 0xf4, 0xad, 0x19,
	0x94, 0x7b, 0xb4, 0x11, 0x3e, 0x52, 0x7c, 0x33, 0xa4, 0xb4, 0xe6, 0xba, 0xce, 0x26, 0x6e, 0x3d,
	0x44, 0x98, 0x64, 0x0d, 0x79, 0x4d, 0x46, 0x40, 0xdd, 0xf1, 0x63, 0xf7, 0x2a, 0x01, 0x52, 0x96,
	0x9a, 0xf7, 0xc6, 0xfd, 0x44, 0x30, 0x42, 0x27, 0xc5, 0x2e, 0x70, 0xf6, 0x73, 0xd7, 0xbb, 0x43,
	0xa6, 0x61, 0x7c, 0xa7, 0xa9, 0x36, 0xf5, 0xe6, 0xc5, 0x6d, 0xed, 0x25, 0xce, 0x54, 0x81, 0x4b,
	0xb3, 0xa8, 0xdf, 0xc0, 0x4d, 0x6c, 0xa8, 0x26, 0xae, 0xee, 0x6e, 0x90, 0xde, 0x3a, 0x22, 0x7b,
	0x93, 0xd0, 0x83, 0xc9, 0x68, 0x0a, 0xc7, 0xa2, 0xda, 0xff, 0x8a, 0xca, 0x75, 0xad, 0x81, 0x89,
	0x7f, 0x3b, 0xf3, 0xf1, 0xb0, 0x9f, 0x23, 0xf5, 0xa6, 0x2e, 0x55, 0x0c, 0x05, 0x11, 0x91, 0xde,
	0x99, 0xb2, 0xa8, 0xd7, 0xd4, 0x46, 0xdb, 0xd4, 0x0d, 0x8c, 0x5e, 0xe0, 0xa2, 0x63, 0x23, 0x90,
	0xf0, 0x20, 0x70, 0x14, 0x32, 0x75, 0xbd, 0xe6, 0x7a, 0x32, 0xb0, 0x27, 0x7e, 0x39, 0x13, 0x78,
	0x8c, 0x88, 0x36, 0xb8, 0xb3, 0xde, 0xd8, 0x2e, 0x90, 0x09, 0x77, 0xb4, 0x28, 0x14, 0x51, 0x43,
	0x88, 0xab, 0x90, 0x84, 0xd4, 0xb2, 0xd6, 0xdc, 0xf0, 0x2e, 0x62, 0x8e, 0x40, 0x5a, 0x6b, 0xd6,
	0xf1, 0x05, 0x36, 0x52, 0xd3, 0x07, 0x6b, 0x38, 0x6f, 0xee, 0x6c, 0xaf, 0x61, 0xa3, 0xb2, 0x4e,
	0x9a, 0xdb, 0x56, 0xf4, 0x2a, 0x6e, 0xda, 0x33, 0xb3, 0xae, 0xef, 0xd0, 0x4f, 0x12, 0xd1, 0xe4,
	0xde, 0xa2, 0xc4, 0x07, 0x17, 0x87, 0xa8, 0xa4, 0x87, 0xa8, 0x48, 0x12, 0xdf, 0xa5, 0xf0, 0xf8,
	0xf9, 0xfb, 0xb9, 0x24, 0x64, 0x97, 0xb0, 0x69, 0x68, 0xb5, 0x36, 0xfa, 0x78, 0x12, 0x26, 0xaa,
	0xd8, 0x5c, 0x56, 0x0d, 0x75, 0x1b, 0x9b, 0xd6, 0x92, 0xfc, 0x7a, 0x4e, 0x31, 0xb5, 0x1a, 0xaa,
	0xb9, 0xae, 0x1b, 0xdb, 0xb6, 0x62, 0xb2, 0x9f, 0x6f, 0x4b, 0x3d, 0xfc, 0x5d, 0x21, 0xc1, 0x33,
	0x33, 0xd0, 0xf5, 0x86, 0x55, 0x38, 0xc3, 0x55, 0xe6, 0x73, 0xc2, 0x22, 0x9c, 0x33, 0x4d, 0x98,
	0x12, 0xe3, 0x67, 0xe6, 0x27, 0x04, 0x10, 0x16, 0xf5, 0x0d, 0xf4, 0x11, 0x01, 0x52, 0x44, 0xbe,
	0xde, 0xed, 0x19, 0x92, 0xa7, 0x20, 0xbb, 0x8d, 0xdb, 0x6d, 0x75, 0x03, 0xdb, 0xf7, 0x4b, 0xb3,
	0x47, 0xe9, 0x34, 0xa4, 0x1b, 0x78, 0x17, 0x37, 0x08, 0x19, 0x93, 0xa7, 0xae, 0xe2, 0x5a, 0xb6,
	0xa8, 0x6f, 0xcc, 0x58, 0x65, 0x39, 0xb7, 0xd0, 0x2e, 0x5a, 0x59, 0x65, 0xfa, 0xc5, 0xf4, 0xbd,
	0x90, 0x26, 0xcf, 0xd2, 0x28, 0xa4, 0x0b, 0xc5, 0xd9, 0x95, 0x79, 0xf1, 0x90, 0xf5, 0xd7, 0xa6,
	0x6f, 0x14, 0xd2, 0x73, 0x39, 0x25, 0xb7, 0x28, 0x26, 0xad, 0x76, 0x94, 0xca, 0x73, 0x15, 0x51,
	0xb0, 0x12, 0x97, 0x73, 0xe5, 0x52, 0x5e, 0x4c, 0x49, 0x63, 0x90, 0x3d, 0x97, 0x93, 0xcb, 0xa5,
	0xf2, 0xbc, 0x98, 0x46, 0x0f, 0x78, 0x15, 0xd6, 0x6d, 0x3c, 0x7e, 0x57, 0xfb, 0xd1, 0xd4, 0x0d,
	0xb2, 0xff, 0xe8, 0x40, 0x76, 0x27, 0x07, 0xd9, 0xf3, 0xc2, 0x14, 0x12, 0x0d, 0xa5, 0x72, 0x1f,
	0x86, 0xec, 0x09, 0x18, 0x2d, 0x57, 0x94, 0xd5, 0xb9, 0xca, 0x4a, 0xb9, 0x20, 0x62, 0x8b, 0x07,
	0x4a, 0x69, 0xa9, 0x58, 0x59, 0x51, 0xc4, 0x75, 0xf4, 0x96, 0x24, 0x64, 0x97, 0x0d, 0xbd, 0x86,
	0xdb, 0x6d, 0xf4, 0xda, 0x24, 0x64, 0xf2, 0x6a, 0xb3, 0x86, 0x1b, 0xe8, 0x39, 0x2e, 0x8c, 0x1d,
	0x4b, 0x42, 0xf4, 0x23, 0xaf, 0xd4, 0xdf, 0xc3, 0x73, 0x8d, 0xbf, 0x57, 0x98, 0x95, 0x3b, 0x43,
	0xcb, 0xf4, 0xe1, 0xdd, 0x63, 0x0e, 0xef, 0xf2, 0x1c, 0xef, 0x4e, 0x86, 0x2f, 0x2a, 0x7e, 0x39,
	0xff, 0x87, 0x04, 0x1c, 0x99, 0xb7, 0xa6, 0x0f, 0x5a, 0x8d, 0x12, 0x6f, 0xb7, 0xff, 0x4e, 0xbe,
	0xfd, 0xd7, 0x72, 0x44, 0x77, 0xfb, 0x82, 0x6f, 0xfc, 0xa3, 0x4e, 0xe3, 0xef, 0xe1, 0x1a, 0x7f,
	0x43, 0xc8, 0x72, 0x62, 0x6f, 0xf9, 0x74, 0x16, 0xd2, 0x64, 0x8a, 0x3c, 0x7d, 0x0d, 0x4c, 0x54,
	0x4d, 0x03, 0xab, 0xdb, 0x9e, 0x41, 0xc9, 0xd4, 0xb7, 0x70, 0x93, 0x89, 0x06, 0x7d, 0xb8, 0xed,
	0x34, 0x64, 0x9b, 0xfa, 0xaa, 0xba, 0x63, 0x6e, 0x4a, 0xcf, 0xdd, 0x73, 0x6c, 0x68, 0x89, 0xf6,
	0xff, 0x4a, 0x8b, 0xee, 0x22, 0xfd, 0xd5, 0x1d, 0x64, 0x62, 0x96, 0x69, 0xea, 0xb9, 0x1d, 0x73,
	0x73, 0xf6, 0xf2, 0xcf, 0x3e, 0x75, 0x2c, 0xf1, 0xc5, 0xa7, 0x8e, 0x25, 0xbe, 0xfd, 0xd4, 0xb1,
	0xc4, 0x6f, 0x7c, 0xe7, 0xd8, 0xa1, 0x2f, 0x7e, 0xe7, 0xd8, 0xa1, 0x6f, 0x7c, 0xe7, 0xd8, 0xa1,
	0x17, 0x27, 0x5b, 0x6b, 0x6b, 0x19, 0x52, 0xca, 0x2d, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x96,
	0x08, 0x71, 0x73, 0x1f, 0x3b, 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 *RpcApp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcApp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcApp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAppGetVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppGetVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppGetVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAppGetVersionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppGetVersionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppGetVersionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAppGetVersionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppGetVersionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppGetVersionResponse) 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 *RpcAppGetVersionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppGetVersionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppGetVersionResponseError) 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 *RpcAppSetDeviceState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppSetDeviceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppSetDeviceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAppSetDeviceStateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppSetDeviceStateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppSetDeviceStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DeviceState != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.DeviceState))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAppSetDeviceStateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppSetDeviceStateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppSetDeviceStateResponse) 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 *RpcAppSetDeviceStateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppSetDeviceStateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppSetDeviceStateResponseError) 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 *RpcAppShutdown) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppShutdown) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppShutdown) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAppShutdownRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppShutdownRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppShutdownRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAppShutdownResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppShutdownResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppShutdownResponse) 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 *RpcAppShutdownResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAppShutdownResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAppShutdownResponseError) 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 *RpcWalletCreateSession) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWalletCreateSessionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateSessionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateSessionRequest) 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] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletCreateSessionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateSessionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Token)))
		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 *RpcWalletCreateSessionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCreateSessionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCreateSessionResponseError) 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 *RpcWalletCloseSession) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCloseSession) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCloseSession) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWalletCloseSessionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCloseSessionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCloseSessionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcWalletCloseSessionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCloseSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCloseSessionResponse) 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 *RpcWalletCloseSessionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWalletCloseSessionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWalletCloseSessionResponseError) 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.EnablePrereleaseChannel {
		i--
		if m.EnablePrereleaseChannel {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.EnableDebug {
		i--
		if m.EnableDebug {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.EnableDataview {
		i--
		if m.EnableDataview {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *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 len(m.StorePath) > 0 {
		i -= len(m.StorePath)
		copy(dAtA[i:], m.StorePath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.StorePath)))
		i--
		dAtA[i] = 0x1a
	}
	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 *RpcAccountDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Revert {
		i--
		if m.Revert {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = 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 *RpcAccountDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountDeleteResponseError) 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 *RpcAccountMove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountMoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountMoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountMoveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NewPath) > 0 {
		i -= len(m.NewPath)
		copy(dAtA[i:], m.NewPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.NewPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountMoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountMoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountMoveResponse) 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 *RpcAccountMoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountMoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountMoveResponseError) 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 *RpcAccountConfigUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountConfigUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountConfigUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountConfigUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountConfigUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IPFSStorageAddr) > 0 {
		i -= len(m.IPFSStorageAddr)
		copy(dAtA[i:], m.IPFSStorageAddr)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.IPFSStorageAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TimeZone) > 0 {
		i -= len(m.TimeZone)
		copy(dAtA[i:], m.TimeZone)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TimeZone)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountConfigUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountConfigUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountConfigUpdateResponse) 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 *RpcAccountConfigUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountConfigUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountConfigUpdateResponseError) 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 *RpcAccountGetConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountGetConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountGetConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountGetConfigGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountGetConfigGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountGetConfigGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountGetConfigGetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountGetConfigGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountGetConfigGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *RpcWorkspaceObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceObjectAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceObjectAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectAddRequest) 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 *RpcWorkspaceObjectAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectAddResponse) 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] = 0x1a
	}
	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] = 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 *RpcWorkspaceObjectAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectAddResponseError) 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 *RpcWorkspaceObjectListAdd) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListAdd) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceObjectListAddRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListAddRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListAddRequest) 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 *RpcWorkspaceObjectListAddResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListAddResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListAddResponse) 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] = 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 *RpcWorkspaceObjectListAddResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListAddResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListAddResponseError) 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 *RpcWorkspaceObjectListRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceObjectListRemoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListRemoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListRemoveRequest) 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 *RpcWorkspaceObjectListRemoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListRemoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListRemoveResponse) 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 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 *RpcWorkspaceObjectListRemoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceObjectListRemoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceObjectListRemoveResponseError) 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 *RpcWorkspaceExport) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcWorkspaceExportRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceExportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceExportRequest) 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 *RpcWorkspaceExportResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceExportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceExportResponse) 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 *RpcWorkspaceExportResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcWorkspaceExportResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcWorkspaceExportResponseError) 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 *RpcObjectOpen) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpen) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectOpenRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IncludeRelationsAsDependentObjects {
		i--
		if m.IncludeRelationsAsDependentObjects {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	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.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		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 *RpcObjectOpenResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ObjectView != nil {
		{
			size, err := m.ObjectView.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 *RpcObjectOpenResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenResponseError) 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 *RpcObjectClose) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectClose) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectClose) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCloseRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCloseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCloseRequest) 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] = 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 *RpcObjectCloseResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCloseResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCloseResponse) 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 *RpcObjectCloseResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCloseResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCloseResponseError) 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 *RpcObjectShow) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShow) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectShowRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShowRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShowRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IncludeRelationsAsDependentObjects {
		i--
		if m.IncludeRelationsAsDependentObjects {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	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.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		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 *RpcObjectShowResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShowResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShowResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ObjectView != nil {
		{
			size, err := m.ObjectView.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 *RpcObjectShowResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectShowResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectShowResponseError) 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 *RpcObjectCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRequest) 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 len(m.InternalFlags) > 0 {
		for iNdEx := len(m.InternalFlags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InternalFlags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	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 *RpcObjectCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateResponse) 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] = 0x2a
	}
	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.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		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 *RpcObjectCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateResponseError) 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 *RpcObjectCreateBookmark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCreateBookmarkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateBookmarkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateBookmarkRequest) 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 *RpcObjectCreateBookmarkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateBookmarkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateBookmarkResponse) 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] = 0x1a
	}
	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] = 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 *RpcObjectCreateBookmarkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateBookmarkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateBookmarkResponseError) 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 *RpcObjectCreateRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCreateRelationRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationRequest) 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 *RpcObjectCreateRelationResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationResponse) 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] = 0x22
	}
	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.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		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 *RpcObjectCreateRelationResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationResponseError) 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 *RpcObjectCreateRelationOption) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationOption) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationOption) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCreateRelationOptionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationOptionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationOptionRequest) 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 *RpcObjectCreateRelationOptionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationOptionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationOptionResponse) 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] = 0x1a
	}
	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] = 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 *RpcObjectCreateRelationOptionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateRelationOptionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateRelationOptionResponseError) 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 *RpcObjectCreateSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCreateSetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateSetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InternalFlags) > 0 {
		for iNdEx := len(m.InternalFlags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InternalFlags[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.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 *RpcObjectCreateSetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateSetResponse) 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] = 0x2a
	}
	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.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		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 *RpcObjectCreateSetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateSetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateSetResponseError) 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 *RpcObjectCreateObjectType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectCreateObjectTypeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateObjectTypeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateObjectTypeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InternalFlags) > 0 {
		for iNdEx := len(m.InternalFlags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InternalFlags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	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 *RpcObjectCreateObjectTypeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateObjectTypeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateObjectTypeResponse) 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] = 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 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 *RpcObjectCreateObjectTypeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectCreateObjectTypeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectCreateObjectTypeResponseError) 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 *RpcObjectBookmarkFetch) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectBookmarkFetch) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectBookmarkFetch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectBookmarkFetchRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectBookmarkFetchRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectBookmarkFetchRequest) 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 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 *RpcObjectBookmarkFetchResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectBookmarkFetchResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectBookmarkFetchResponse) 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 *RpcObjectBookmarkFetchResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectBookmarkFetchResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectBookmarkFetchResponseError) 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 *RpcObjectToBookmark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectToBookmarkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToBookmarkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToBookmarkRequest) 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 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 *RpcObjectToBookmarkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToBookmarkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToBookmarkResponse) 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] = 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 *RpcObjectToBookmarkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectToBookmarkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectToBookmarkResponseError) 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 *RpcObjectOpenBreadcrumbs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenBreadcrumbs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenBreadcrumbs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectOpenBreadcrumbsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenBreadcrumbsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenBreadcrumbsRequest) 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 *RpcObjectOpenBreadcrumbsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenBreadcrumbsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenBreadcrumbsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ObjectView != nil {
		{
			size, err := m.ObjectView.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	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.ObjectId) > 0 {
		i -= len(m.ObjectId)
		copy(dAtA[i:], m.ObjectId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ObjectId)))
		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 *RpcObjectOpenBreadcrumbsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectOpenBreadcrumbsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectOpenBreadcrumbsResponseError) 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 *RpcObjectSetBreadcrumbs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetBreadcrumbs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetBreadcrumbs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetBreadcrumbsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetBreadcrumbsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetBreadcrumbsRequest) 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 *RpcObjectSetBreadcrumbsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetBreadcrumbsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetBreadcrumbsResponse) 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 *RpcObjectSetBreadcrumbsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetBreadcrumbsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetBreadcrumbsResponseError) 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 *RpcObjectImportMarkdown) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportMarkdown) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportMarkdown) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportMarkdownRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportMarkdownRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportMarkdownRequest) 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 *RpcObjectImportMarkdownResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportMarkdownResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportMarkdownResponse) 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 *RpcObjectImportMarkdownResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportMarkdownResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportMarkdownResponseError) 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 *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 *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.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] = 0x22
		}
	}
	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 *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 *RpcObjectGroupsSubscribe) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGroupsSubscribe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGroupsSubscribe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectGroupsSubscribeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGroupsSubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGroupsSubscribeRequest) 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] = 0x22
		}
	}
	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] = 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.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 *RpcObjectGroupsSubscribeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGroupsSubscribeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGroupsSubscribeResponse) 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] = 0x1a
	}
	if len(m.Groups) > 0 {
		for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Groups[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 *RpcObjectGroupsSubscribeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectGroupsSubscribeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectGroupsSubscribeResponseError) 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 *RpcObjectSubscribeIds) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSubscribeIds) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSubscribeIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSubscribeIdsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSubscribeIdsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSubscribeIdsRequest) 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 *RpcObjectSubscribeIdsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSubscribeIdsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSubscribeIdsResponse) 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 *RpcObjectSubscribeIdsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSubscribeIdsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSubscribeIdsResponseError) 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 *RpcObjectSetObjectType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetObjectTypeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetObjectTypeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetObjectTypeRequest) 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 *RpcObjectSetObjectTypeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetObjectTypeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetObjectTypeResponse) 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 *RpcObjectSetObjectTypeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetObjectTypeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetObjectTypeResponseError) 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 *RpcObjectSetInternalFlags) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetInternalFlags) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetInternalFlags) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetInternalFlagsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetInternalFlagsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetInternalFlagsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InternalFlags) > 0 {
		for iNdEx := len(m.InternalFlags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InternalFlags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	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 *RpcObjectSetInternalFlagsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetInternalFlagsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetInternalFlagsResponse) 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 *RpcObjectSetInternalFlagsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetInternalFlagsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetInternalFlagsResponseError) 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 *RpcObjectSetDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectSetDetailsDetail) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetDetailsDetail) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetDetailsDetail) 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 *RpcObjectSetDetailsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetDetailsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetDetailsRequest) 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 *RpcObjectSetDetailsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetDetailsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetDetailsResponse) 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 *RpcObjectSetDetailsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectSetDetailsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectSetDetailsResponseError) 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 *RpcObjectUndoRedoCounter) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectUndoRedoCounter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectUndoRedoCounter) 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 *RpcObjectUndo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectUndo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectUndo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectUndoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectUndoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectUndoRequest) 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 *RpcObjectUndoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectUndoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectUndoResponse) 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 *RpcObjectUndoResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectUndoResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectUndoResponseError) 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 *RpcObjectRedo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRedo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRedo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRedoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRedoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRedoRequest) 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 *RpcObjectRedoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRedoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRedoResponse) 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 *RpcObjectRedoResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRedoResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRedoResponseError) 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 *RpcObjectListDuplicate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDuplicate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListDuplicateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDuplicateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDuplicateRequest) 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 *RpcObjectListDuplicateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDuplicateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDuplicateResponse) 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 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 *RpcObjectListDuplicateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListDuplicateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListDuplicateResponseError) 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 *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 *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 *RpcObjectApplyTemplate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectApplyTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectApplyTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectApplyTemplateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectApplyTemplateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectApplyTemplateRequest) 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 *RpcObjectApplyTemplateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectApplyTemplateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectApplyTemplateResponse) 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 *RpcObjectApplyTemplateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectApplyTemplateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectApplyTemplateResponseError) 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 *RpcObjectListExport) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListExport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListExport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectListExportRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListExportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListExportRequest) 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.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] = 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 *RpcObjectListExportResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListExportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListExportResponse) 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 *RpcObjectListExportResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectListExportResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectListExportResponseError) 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 *RpcObjectImport) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequest) 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] = 0x38
	}
	if m.Type != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x30
	}
	if m.UpdateExistingObjects {
		i--
		if m.UpdateExistingObjects {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.Snapshots) > 0 {
		for iNdEx := len(m.Snapshots) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Snapshots[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Params != nil {
		{
			size := m.Params.Size()
			i -= size
			if _, err := m.Params.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportRequestParamsOfNotionParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestParamsOfNotionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NotionParams != nil {
		{
			size, err := m.NotionParams.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 *RpcObjectImportRequestParamsOfBookmarksParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestParamsOfBookmarksParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BookmarksParams != nil {
		{
			size, err := m.BookmarksParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *RpcObjectImportRequestParamsOfMarkdownParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestParamsOfMarkdownParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MarkdownParams != nil {
		{
			size, err := m.MarkdownParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *RpcObjectImportRequestNotionParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportRequestNotionParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestNotionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ApiKey) > 0 {
		i -= len(m.ApiKey)
		copy(dAtA[i:], m.ApiKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ApiKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportRequestMarkdownParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportRequestMarkdownParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestMarkdownParams) 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 *RpcObjectImportRequestBookmarksParams) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportRequestBookmarksParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestBookmarksParams) 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 *RpcObjectImportRequestSnapshot) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportRequestSnapshot) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportRequestSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Snapshot != nil {
		{
			size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		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 *RpcObjectImportResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportResponse) 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 *RpcObjectImportResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportResponseError) 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 *RpcObjectImportNotion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportNotion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportNotion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportNotionTokenValidate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportNotionTokenValidate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportNotionTokenValidate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportNotionTokenValidateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportNotionTokenValidateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportNotionTokenValidateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ApiKey) > 0 {
		i -= len(m.ApiKey)
		copy(dAtA[i:], m.ApiKey)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ApiKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportNotionTokenValidateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportNotionTokenValidateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportNotionTokenValidateResponse) 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 *RpcObjectImportNotionTokenValidateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportNotionTokenValidateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportNotionTokenValidateResponseError) 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 *RpcObjectImportList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportListRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportListRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectImportListResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportListResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Response) > 0 {
		for iNdEx := len(m.Response) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Response[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 *RpcObjectImportListResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportListResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportListResponseError) 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 *RpcObjectImportListImportResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectImportListImportResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectImportListImportResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 len(m.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKeys[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 *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.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 *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.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKeys[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 *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 *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 *RpcObjectRelationAddFeatured) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddFeatured) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddFeatured) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationAddFeaturedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddFeaturedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddFeaturedRequest) 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 *RpcObjectRelationAddFeaturedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddFeaturedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddFeaturedResponse) 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 *RpcObjectRelationAddFeaturedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationAddFeaturedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationAddFeaturedResponseError) 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 *RpcObjectRelationRemoveFeatured) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationRemoveFeatured) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationRemoveFeatured) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcObjectRelationRemoveFeaturedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationRemoveFeaturedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationRemoveFeaturedRequest) 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 *RpcObjectRelationRemoveFeaturedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationRemoveFeaturedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationRemoveFeaturedResponse) 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 *RpcObjectRelationRemoveFeaturedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcObjectRelationRemoveFeaturedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcObjectRelationRemoveFeaturedResponseError) 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 *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.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKeys[iNdEx])))
			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.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKeys[iNdEx])))
			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 *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 *RpcRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcRelationListRemoveOption) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationListRemoveOption) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationListRemoveOption) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcRelationListRemoveOptionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationListRemoveOptionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationListRemoveOptionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CheckInObjects {
		i--
		if m.CheckInObjects {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.OptionIds) > 0 {
		for iNdEx := len(m.OptionIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.OptionIds[iNdEx])
			copy(dAtA[i:], m.OptionIds[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.OptionIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcRelationListRemoveOptionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationListRemoveOptionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationListRemoveOptionResponse) 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 *RpcRelationListRemoveOptionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationListRemoveOptionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationListRemoveOptionResponseError) 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 *RpcRelationOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationOptions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcRelationOptionsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationOptionsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationOptionsRequest) 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] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcRelationOptionsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationOptionsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationOptionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Options != nil {
		{
			size, err := m.Options.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 *RpcRelationOptionsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcRelationOptionsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcRelationOptionsResponseError) 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 *RpcHistoryVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryVersion) 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 *RpcHistoryGetVersions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryGetVersions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryGetVersions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcHistoryGetVersionsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryGetVersionsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryGetVersionsRequest) 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.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 *RpcHistoryGetVersionsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryGetVersionsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryGetVersionsResponse) 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 *RpcHistoryGetVersionsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryGetVersionsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryGetVersionsResponseError) 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 *RpcHistoryShowVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcHistoryShowVersionRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowVersionRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowVersionRequest) 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.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 *RpcHistoryShowVersionResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowVersionResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowVersionResponse) 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.ObjectView != nil {
		{
			size, err := m.ObjectView.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 *RpcHistoryShowVersionResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcHistoryShowVersionResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcHistoryShowVersionResponseError) 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.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 *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 *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 *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 *RpcFileUpload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileUpload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileUploadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileUploadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileUploadRequest) 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 *RpcFileUploadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileUploadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileUploadResponse) 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 *RpcFileUploadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileUploadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileUploadResponseError) 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 *RpcFileDownload) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDownload) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDownload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileDownloadRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDownloadRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDownloadRequest) 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 *RpcFileDownloadResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDownloadResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDownloadResponse) 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 *RpcFileDownloadResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDownloadResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDownloadResponseError) 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 *RpcFileDrop) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDrop) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDrop) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcFileDropRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDropRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDropRequest) 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 *RpcFileDropResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDropResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDropResponse) 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 *RpcFileDropResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcFileDropResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcFileDropResponseError) 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 *RpcTemplate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcTemplateCreateFromObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcTemplateCreateFromObjectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectRequest) 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 *RpcTemplateCreateFromObjectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectResponse) 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 *RpcTemplateCreateFromObjectResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectResponseError) 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 *RpcTemplateCreateFromObjectType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcTemplateCreateFromObjectTypeRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectTypeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectTypeRequest) 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 *RpcTemplateCreateFromObjectTypeResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectTypeResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectTypeResponse) 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 *RpcTemplateCreateFromObjectTypeResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCreateFromObjectTypeResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCreateFromObjectTypeResponseError) 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 *RpcTemplateClone) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateClone) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateClone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcTemplateCloneRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCloneRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCloneRequest) 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 *RpcTemplateCloneResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCloneResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCloneResponse) 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 *RpcTemplateCloneResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateCloneResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateCloneResponseError) 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 *RpcTemplateExportAll) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateExportAll) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateExportAll) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcTemplateExportAllRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateExportAllRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateExportAllRequest) 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 *RpcTemplateExportAllResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateExportAllResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateExportAllResponse) 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 *RpcTemplateExportAllResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcTemplateExportAllResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcTemplateExportAllResponseError) 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 *RpcUnsplash) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcUnsplash) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcUnsplash) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *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 *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 *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 *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 *RpcBlockCreateWidget) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateWidget) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateWidget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCreateWidgetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateWidgetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateWidgetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.WidgetLayout != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.WidgetLayout))
		i--
		dAtA[i] = 0x28
	}
	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 *RpcBlockCreateWidgetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateWidgetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateWidgetResponse) 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 *RpcBlockCreateWidgetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCreateWidgetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCreateWidgetResponseError) 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 *RpcBlockListDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDeleteRequest) 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 *RpcBlockListDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDeleteResponse) 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 *RpcBlockListDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListDeleteResponseError) 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 *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 *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 *RpcBlockListSetVerticalAlign) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetVerticalAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetVerticalAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListSetVerticalAlignRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetVerticalAlignRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetVerticalAlignRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VerticalAlign != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.VerticalAlign))
		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 *RpcBlockListSetVerticalAlignResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetVerticalAlignResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetVerticalAlignResponse) 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 *RpcBlockListSetVerticalAlignResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListSetVerticalAlignResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListSetVerticalAlignResponseError) 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 *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 len(m.TargetContextId) > 0 {
		i -= len(m.TargetContextId)
		copy(dAtA[i:], m.TargetContextId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.TargetContextId)))
		i--
		dAtA[i] = 0x2a
	}
	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 *RpcBlockListUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Field != nil {
		{
			size := m.Field.Size()
			i -= size
			if _, err := m.Field.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	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 *RpcBlockListUpdateRequestFieldOfText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestFieldOfText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Text != nil {
		{
			size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestFieldOfBackgroundColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestFieldOfBackgroundColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.BackgroundColor)
	copy(dAtA[i:], m.BackgroundColor)
	i = encodeVarintCommands(dAtA, i, uint64(len(m.BackgroundColor)))
	i--
	dAtA[i] = 0x22
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestFieldOfAlign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestFieldOfAlign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintCommands(dAtA, i, uint64(m.Align))
	i--
	dAtA[i] = 0x28
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestFieldOfFields) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestFieldOfFields) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	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
	}
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestFieldOfDivStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestFieldOfDivStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintCommands(dAtA, i, uint64(m.DivStyle))
	i--
	dAtA[i] = 0x38
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestFieldOfFileStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestFieldOfFileStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintCommands(dAtA, i, uint64(m.FileStyle))
	i--
	dAtA[i] = 0x40
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListUpdateRequestText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Field != nil {
		{
			size := m.Field.Size()
			i -= size
			if _, err := m.Field.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockListUpdateRequestTextFieldOfStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestTextFieldOfStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintCommands(dAtA, i, uint64(m.Style))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestTextFieldOfColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestTextFieldOfColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.Color)
	copy(dAtA[i:], m.Color)
	i = encodeVarintCommands(dAtA, i, uint64(len(m.Color)))
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}
func (m *RpcBlockListUpdateRequestTextFieldOfMark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListUpdateRequestTextFieldOfMark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	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
	}
	return len(dAtA) - i, nil
}
func (m *RpcBlockListConvertToObjects) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertToObjects) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertToObjects) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListConvertToObjectsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertToObjectsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertToObjectsRequest) 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 *RpcBlockListConvertToObjectsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertToObjectsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertToObjectsResponse) 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.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 *RpcBlockListConvertToObjectsResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListConvertToObjectsResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListConvertToObjectsResponseError) 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 *RpcBlockListMoveToExistingObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToExistingObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToExistingObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveToExistingObjectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToExistingObjectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToExistingObjectRequest) 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 *RpcBlockListMoveToExistingObjectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToExistingObjectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToExistingObjectResponse) 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 *RpcBlockListMoveToExistingObjectResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToExistingObjectResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToExistingObjectResponseError) 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 *RpcBlockListMoveToNewObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockListMoveToNewObjectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewObjectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewObjectRequest) 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 *RpcBlockListMoveToNewObjectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewObjectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewObjectResponse) 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 *RpcBlockListMoveToNewObjectResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockListMoveToNewObjectResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockListMoveToNewObjectResponseError) 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 *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 *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 *RpcBlockLatex) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLatex) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLatex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockLatexSetText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLatexSetText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLatexSetText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockLatexSetTextRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLatexSetTextRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLatexSetTextRequest) 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 *RpcBlockLatexSetTextResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLatexSetTextResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLatexSetTextResponse) 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 *RpcBlockLatexSetTextResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLatexSetTextResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLatexSetTextResponseError) 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 *RpcBlockText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetText) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetText) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetTextRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetTextRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetTextRequest) 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 *RpcBlockTextSetTextResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetTextResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetTextResponse) 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 *RpcBlockTextSetTextResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetTextResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetTextResponseError) 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 *RpcBlockTextSetColor) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetColorRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetColorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetColorRequest) 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 *RpcBlockTextSetColorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetColorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetColorResponse) 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 *RpcBlockTextSetColorResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetColorResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetColorResponseError) 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 *RpcBlockTextSetMarks) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetMarks) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetMarks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetMarksGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetMarksGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetMarksGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetMarksGetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetMarksGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetMarksGetRequest) 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 *RpcBlockTextSetMarksGetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetMarksGetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetMarksGetResponse) 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 *RpcBlockTextSetMarksGetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetMarksGetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetMarksGetResponseError) 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 *RpcBlockTextSetStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetStyleRequest) 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 *RpcBlockTextSetStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetStyleResponse) 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 *RpcBlockTextSetStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetStyleResponseError) 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 *RpcBlockTextSetChecked) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetChecked) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetChecked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetCheckedRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetCheckedRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetCheckedRequest) 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 *RpcBlockTextSetCheckedResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetCheckedResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetCheckedResponse) 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 *RpcBlockTextSetCheckedResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetCheckedResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetCheckedResponseError) 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 *RpcBlockTextSetIcon) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetIcon) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetIcon) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextSetIconRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetIconRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetIconRequest) 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 *RpcBlockTextSetIconResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetIconResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetIconResponse) 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 *RpcBlockTextSetIconResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextSetIconResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextSetIconResponseError) 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 *RpcBlockTextListSetStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextListSetStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetStyleRequest) 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 *RpcBlockTextListSetStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetStyleResponse) 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 *RpcBlockTextListSetStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetStyleResponseError) 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 *RpcBlockTextListSetColor) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextListSetColorRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetColorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetColorRequest) 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 *RpcBlockTextListSetColorResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetColorResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetColorResponse) 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 *RpcBlockTextListSetColorResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetColorResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetColorResponseError) 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 *RpcBlockTextListSetMark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetMark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetMark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextListSetMarkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetMarkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetMarkRequest) 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 *RpcBlockTextListSetMarkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetMarkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetMarkResponse) 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 *RpcBlockTextListSetMarkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListSetMarkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListSetMarkResponseError) 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 *RpcBlockTextListClearStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextListClearStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearStyleRequest) 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 *RpcBlockTextListClearStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearStyleResponse) 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 *RpcBlockTextListClearStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearStyleResponseError) 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 *RpcBlockTextListClearContent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTextListClearContentRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearContentRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearContentRequest) 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 *RpcBlockTextListClearContentResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearContentResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearContentResponse) 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 *RpcBlockTextListClearContentResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTextListClearContentResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTextListClearContentResponseError) 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 *RpcBlockTable) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.WithHeaderRow {
		i--
		if m.WithHeaderRow {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Columns != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Columns))
		i--
		dAtA[i] = 0x28
	}
	if m.Rows != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Rows))
		i--
		dAtA[i] = 0x20
	}
	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 *RpcBlockTableCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableCreateResponse) 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 *RpcBlockTableCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableCreateResponseError) 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 *RpcBlockTableRowCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableRowCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowCreateRequest) 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] = 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 *RpcBlockTableRowCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowCreateResponse) 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 *RpcBlockTableRowCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowCreateResponseError) 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 *RpcBlockTableRowSetHeader) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowSetHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableRowSetHeaderRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowSetHeaderRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowSetHeaderRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsHeader {
		i--
		if m.IsHeader {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 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 *RpcBlockTableRowSetHeaderResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowSetHeaderResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowSetHeaderResponse) 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 *RpcBlockTableRowSetHeaderResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowSetHeaderResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowSetHeaderResponseError) 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 *RpcBlockTableRowListFill) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListFill) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListFill) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableRowListFillRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListFillRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListFillRequest) 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 *RpcBlockTableRowListFillResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListFillResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListFillResponse) 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 *RpcBlockTableRowListFillResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListFillResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListFillResponseError) 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 *RpcBlockTableRowListClean) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListClean) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListClean) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableRowListCleanRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListCleanRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListCleanRequest) 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 *RpcBlockTableRowListCleanResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListCleanResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListCleanResponse) 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 *RpcBlockTableRowListCleanResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowListCleanResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowListCleanResponseError) 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 *RpcBlockTableColumnListFill) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnListFill) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnListFill) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableColumnListFillRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnListFillRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnListFillRequest) 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 *RpcBlockTableColumnListFillResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnListFillResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnListFillResponse) 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 *RpcBlockTableColumnListFillResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnListFillResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnListFillResponseError) 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 *RpcBlockTableColumnCreate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnCreate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableColumnCreateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnCreateRequest) 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] = 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 *RpcBlockTableColumnCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnCreateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnCreateResponse) 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 *RpcBlockTableColumnCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnCreateResponseError) 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 *RpcBlockTableRowDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableRowDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *RpcBlockTableRowDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDeleteResponse) 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 *RpcBlockTableRowDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDeleteResponseError) 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 *RpcBlockTableColumnDelete) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDelete) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableColumnDeleteRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *RpcBlockTableColumnDeleteResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDeleteResponse) 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 *RpcBlockTableColumnDeleteResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDeleteResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDeleteResponseError) 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 *RpcBlockTableColumnMove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableColumnMoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnMoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnMoveRequest) 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.DropTargetId) > 0 {
		i -= len(m.DropTargetId)
		copy(dAtA[i:], m.DropTargetId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.DropTargetId)))
		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 *RpcBlockTableColumnMoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnMoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnMoveResponse) 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 *RpcBlockTableColumnMoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnMoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnMoveResponseError) 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 *RpcBlockTableRowDuplicate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDuplicate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableRowDuplicateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDuplicateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDuplicateRequest) 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.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		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 *RpcBlockTableRowDuplicateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDuplicateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDuplicateResponse) 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 *RpcBlockTableRowDuplicateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableRowDuplicateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableRowDuplicateResponseError) 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 *RpcBlockTableColumnDuplicate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDuplicate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDuplicate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableColumnDuplicateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDuplicateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDuplicateRequest) 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.BlockId) > 0 {
		i -= len(m.BlockId)
		copy(dAtA[i:], m.BlockId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.BlockId)))
		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 *RpcBlockTableColumnDuplicateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDuplicateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDuplicateResponse) 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 *RpcBlockTableColumnDuplicateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableColumnDuplicateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableColumnDuplicateResponseError) 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 *RpcBlockTableExpand) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableExpand) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableExpand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableExpandRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableExpandRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableExpandRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Rows != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Rows))
		i--
		dAtA[i] = 0x20
	}
	if m.Columns != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Columns))
		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 *RpcBlockTableExpandResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableExpandResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableExpandResponse) 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 *RpcBlockTableExpandResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableExpandResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableExpandResponseError) 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 *RpcBlockTableSort) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableSort) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableSort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockTableSortRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableSortRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableSortRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ColumnId) > 0 {
		i -= len(m.ColumnId)
		copy(dAtA[i:], m.ColumnId)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.ColumnId)))
		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 *RpcBlockTableSortResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableSortResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableSortResponse) 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 *RpcBlockTableSortResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockTableSortResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockTableSortResponseError) 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 *RpcBlockFileSetName) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileSetName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileSetName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockFileSetNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileSetNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileSetNameRequest) 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 *RpcBlockFileSetNameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileSetNameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileSetNameResponse) 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 *RpcBlockFileSetNameResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileSetNameResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileSetNameResponseError) 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 *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 *RpcBlockFileListSetStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileListSetStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileListSetStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockFileListSetStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileListSetStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileListSetStyleRequest) 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 *RpcBlockFileListSetStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileListSetStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileListSetStyleResponse) 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 *RpcBlockFileListSetStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockFileListSetStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockFileListSetStyleResponseError) 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 *RpcBlockImage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockImageSetName) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockImageSetNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetNameRequest) 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 *RpcBlockImageSetNameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetNameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetNameResponse) 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 *RpcBlockImageSetNameResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetNameResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetNameResponseError) 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 *RpcBlockImageSetWidth) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetWidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetWidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockImageSetWidthRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetWidthRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetWidthRequest) 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 *RpcBlockImageSetWidthResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetWidthResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetWidthResponse) 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 *RpcBlockImageSetWidthResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockImageSetWidthResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockImageSetWidthResponseError) 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 *RpcBlockVideo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockVideoSetName) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetName) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockVideoSetNameRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetNameRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetNameRequest) 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 *RpcBlockVideoSetNameResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetNameResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetNameResponse) 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 *RpcBlockVideoSetNameResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetNameResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetNameResponseError) 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 *RpcBlockVideoSetWidth) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetWidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetWidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockVideoSetWidthRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetWidthRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetWidthRequest) 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 *RpcBlockVideoSetWidthResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetWidthResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetWidthResponse) 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 *RpcBlockVideoSetWidthResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockVideoSetWidthResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockVideoSetWidthResponseError) 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 *RpcBlockLink) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockLinkCreateWithObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkCreateWithObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkCreateWithObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockLinkCreateWithObjectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkCreateWithObjectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkCreateWithObjectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InternalFlags) > 0 {
		for iNdEx := len(m.InternalFlags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InternalFlags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCommands(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	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 *RpcBlockLinkCreateWithObjectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkCreateWithObjectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkCreateWithObjectResponse) 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 *RpcBlockLinkCreateWithObjectResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkCreateWithObjectResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkCreateWithObjectResponseError) 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 *RpcBlockLinkListSetAppearance) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkListSetAppearance) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkListSetAppearance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockLinkListSetAppearanceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkListSetAppearanceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkListSetAppearanceRequest) 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] = 0x3a
		}
	}
	if m.Description != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Description))
		i--
		dAtA[i] = 0x30
	}
	if m.CardStyle != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.CardStyle))
		i--
		dAtA[i] = 0x28
	}
	if m.IconSize != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.IconSize))
		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] = 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 *RpcBlockLinkListSetAppearanceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkListSetAppearanceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkListSetAppearanceResponse) 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 *RpcBlockLinkListSetAppearanceResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockLinkListSetAppearanceResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockLinkListSetAppearanceResponseError) 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 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 *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 *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 *RpcBlockDiv) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDiv) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDiv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDivListSetStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDivListSetStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDivListSetStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDivListSetStyleRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDivListSetStyleRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDivListSetStyleRequest) 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 *RpcBlockDivListSetStyleResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDivListSetStyleResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDivListSetStyleResponse) 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 *RpcBlockDivListSetStyleResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDivListSetStyleResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDivListSetStyleResponseError) 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 *RpcBlockDataviewView) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewView) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewView) 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 *RpcBlockDataviewRelation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewRelation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewRelation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 len(m.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKeys[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 *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.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 *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.RelationKeys) > 0 {
		for iNdEx := len(m.RelationKeys) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RelationKeys[iNdEx])
			copy(dAtA[i:], m.RelationKeys[iNdEx])
			i = encodeVarintCommands(dAtA, i, uint64(len(m.RelationKeys[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 *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 *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 *RpcBlockDataviewGroupOrder) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewGroupOrder) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewGroupOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewGroupOrderUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewGroupOrderUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewGroupOrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GroupOrder != nil {
		{
			size, err := m.GroupOrder.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = 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 *RpcBlockDataviewGroupOrderUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewGroupOrderUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewGroupOrderUpdateResponse) 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 *RpcBlockDataviewGroupOrderUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewGroupOrderUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewGroupOrderUpdateResponseError) 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 *RpcBlockDataviewObjectOrder) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewObjectOrder) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewObjectOrder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewObjectOrderUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewObjectOrderUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewObjectOrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ObjectOrders) > 0 {
		for iNdEx := len(m.ObjectOrders) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ObjectOrders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = 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 *RpcBlockDataviewObjectOrderUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewObjectOrderUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewObjectOrderUpdateResponse) 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 *RpcBlockDataviewObjectOrderUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewObjectOrderUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewObjectOrderUpdateResponseError) 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 *RpcBlockDataviewCreateBookmark) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewCreateBookmark) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewCreateBookmark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockDataviewCreateBookmarkRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewCreateBookmarkRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewCreateBookmarkRequest) 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 *RpcBlockDataviewCreateBookmarkResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewCreateBookmarkResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewCreateBookmarkResponse) 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 *RpcBlockDataviewCreateBookmarkResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockDataviewCreateBookmarkResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockDataviewCreateBookmarkResponseError) 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.GenerateSvg {
		i--
		if m.GenerateSvg {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	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.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 *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 *RpcDebugExportLocalstore) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugExportLocalstore) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugExportLocalstore) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDebugExportLocalstoreRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugExportLocalstoreRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugExportLocalstoreRequest) 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 *RpcDebugExportLocalstoreResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugExportLocalstoreResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugExportLocalstoreResponse) 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 *RpcDebugExportLocalstoreResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugExportLocalstoreResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugExportLocalstoreResponseError) 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 *RpcDebugPing) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugPing) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcDebugPingRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugPingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugPingRequest) 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 *RpcDebugPingResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugPingResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugPingResponse) 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 *RpcDebugPingResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcDebugPingResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcDebugPingResponseError) 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 *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 *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 *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 *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 (m *StreamRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StreamRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StreamRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	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 *RpcApp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAppGetVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAppGetVersionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAppGetVersionResponse) 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 *RpcAppGetVersionResponseError) 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 *RpcAppSetDeviceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAppSetDeviceStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DeviceState != 0 {
		n += 1 + sovCommands(uint64(m.DeviceState))
	}
	return n
}

func (m *RpcAppSetDeviceStateResponse) 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 *RpcAppSetDeviceStateResponseError) 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 *RpcAppShutdown) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAppShutdownRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAppShutdownResponse) 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 *RpcAppShutdownResponseError) 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 *RpcWalletCreateSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWalletCreateSessionRequest) 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))
	}
	return n
}

func (m *RpcWalletCreateSessionResponse) 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.Token)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletCreateSessionResponseError) 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 *RpcWalletCloseSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWalletCloseSessionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWalletCloseSessionResponse) 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 *RpcWalletCloseSessionResponseError) 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.EnablePrereleaseChannel {
		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.StorePath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	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 *RpcAccountDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountDeleteRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Revert {
		n += 2
	}
	return n
}

func (m *RpcAccountDeleteResponse) 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.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountDeleteResponseError) 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 *RpcAccountMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountMoveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NewPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountMoveResponse) 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 *RpcAccountMoveResponseError) 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 *RpcAccountConfigUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountConfigUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TimeZone)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.IPFSStorageAddr)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountConfigUpdateResponse) 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 *RpcAccountConfigUpdateResponseError) 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 *RpcAccountGetConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountGetConfigGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountGetConfigGetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = 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 *RpcWorkspaceObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceObjectAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceObjectAddRequest) 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 *RpcWorkspaceObjectAddResponse) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcWorkspaceObjectAddResponseError) 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 *RpcWorkspaceObjectListAdd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceObjectListAddRequest) 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 *RpcWorkspaceObjectListAddResponse) 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.ObjectIds) > 0 {
		for _, s := range m.ObjectIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcWorkspaceObjectListAddResponseError) 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 *RpcWorkspaceObjectListRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceObjectListRemoveRequest) 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 *RpcWorkspaceObjectListRemoveResponse) 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.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcWorkspaceObjectListRemoveResponseError) 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 *RpcWorkspaceExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcWorkspaceExportRequest) 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 *RpcWorkspaceExportResponse) 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 *RpcWorkspaceExportResponseError) 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 *RpcObjectOpen) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectOpenRequest) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IncludeRelationsAsDependentObjects {
		n += 2
	}
	return n
}

func (m *RpcObjectOpenResponse) 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.ObjectView != nil {
		l = m.ObjectView.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectOpenResponseError) 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 *RpcObjectClose) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCloseRequest) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCloseResponse) 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 *RpcObjectCloseResponseError) 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 *RpcObjectShow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectShowRequest) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.TraceId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.IncludeRelationsAsDependentObjects {
		n += 2
	}
	return n
}

func (m *RpcObjectShowResponse) 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.ObjectView != nil {
		l = m.ObjectView.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectShowResponseError) 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 *RpcObjectCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCreateRequest) 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))
	}
	if len(m.InternalFlags) > 0 {
		for _, e := range m.InternalFlags {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	l = len(m.TemplateId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateResponse) 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.ObjectId)
	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.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateResponseError) 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 *RpcObjectCreateBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCreateBookmarkRequest) 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 *RpcObjectCreateBookmarkResponse) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateBookmarkResponseError) 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 *RpcObjectCreateRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCreateRelationRequest) 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 *RpcObjectCreateRelationResponse) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateRelationResponseError) 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 *RpcObjectCreateRelationOption) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCreateRelationOptionRequest) 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 *RpcObjectCreateRelationOptionResponse) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateRelationOptionResponseError) 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 *RpcObjectCreateSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCreateSetRequest) 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))
	}
	if len(m.InternalFlags) > 0 {
		for _, e := range m.InternalFlags {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectCreateSetResponse) 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.ObjectId)
	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.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateSetResponseError) 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 *RpcObjectCreateObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectCreateObjectTypeRequest) 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))
	}
	if len(m.InternalFlags) > 0 {
		for _, e := range m.InternalFlags {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectCreateObjectTypeResponse) 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.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectCreateObjectTypeResponseError) 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 *RpcObjectBookmarkFetch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectBookmarkFetchRequest) 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.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectBookmarkFetchResponse) 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 *RpcObjectBookmarkFetchResponseError) 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 *RpcObjectToBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectToBookmarkRequest) 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.Url)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectToBookmarkResponse) 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.ObjectId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectToBookmarkResponseError) 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 *RpcObjectOpenBreadcrumbs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectOpenBreadcrumbsRequest) 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 *RpcObjectOpenBreadcrumbsResponse) 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.ObjectId)
	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.ObjectView != nil {
		l = m.ObjectView.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectOpenBreadcrumbsResponseError) 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 *RpcObjectSetBreadcrumbs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetBreadcrumbsRequest) 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 *RpcObjectSetBreadcrumbsResponse) 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 *RpcObjectSetBreadcrumbsResponseError) 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 *RpcObjectImportMarkdown) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectImportMarkdownRequest) 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 *RpcObjectImportMarkdownResponse) 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 *RpcObjectImportMarkdownResponseError) 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 *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 *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))
		}
	}
	if len(m.Keys) > 0 {
		for _, s := range m.Keys {
			l = len(s)
			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 *RpcObjectGroupsSubscribe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectGroupsSubscribeRequest) 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))
	}
	l = len(m.RelationKey)
	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.Source) > 0 {
		for _, s := range m.Source {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectGroupsSubscribeResponse) 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.Groups) > 0 {
		for _, e := range m.Groups {
			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 *RpcObjectGroupsSubscribeResponseError) 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 *RpcObjectSubscribeIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSubscribeIdsRequest) 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 *RpcObjectSubscribeIdsResponse) 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 *RpcObjectSubscribeIdsResponseError) 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 *RpcObjectSetObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetObjectTypeRequest) 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 *RpcObjectSetObjectTypeResponse) 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 *RpcObjectSetObjectTypeResponseError) 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 *RpcObjectSetInternalFlags) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetInternalFlagsRequest) 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.InternalFlags) > 0 {
		for _, e := range m.InternalFlags {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectSetInternalFlagsResponse) 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 *RpcObjectSetInternalFlagsResponseError) 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 *RpcObjectSetDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectSetDetailsDetail) 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 *RpcObjectSetDetailsRequest) 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 *RpcObjectSetDetailsResponse) 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 *RpcObjectSetDetailsResponseError) 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 *RpcObjectUndoRedoCounter) 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 *RpcObjectUndo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectUndoRequest) 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 *RpcObjectUndoResponse) 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 *RpcObjectUndoResponseError) 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 *RpcObjectRedo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRedoRequest) 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 *RpcObjectRedoResponse) 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 *RpcObjectRedoResponseError) 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 *RpcObjectListDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListDuplicateRequest) 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 *RpcObjectListDuplicateResponse) 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.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectListDuplicateResponseError) 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 *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 *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 *RpcObjectApplyTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectApplyTemplateRequest) 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 *RpcObjectApplyTemplateResponse) 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 *RpcObjectApplyTemplateResponseError) 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 *RpcObjectListExport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectListExportRequest) 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.ObjectIds) > 0 {
		for _, s := range m.ObjectIds {
			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 *RpcObjectListExportResponse) 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 *RpcObjectListExportResponseError) 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 *RpcObjectImport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectImportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Params != nil {
		n += m.Params.Size()
	}
	if len(m.Snapshots) > 0 {
		for _, e := range m.Snapshots {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.UpdateExistingObjects {
		n += 2
	}
	if m.Type != 0 {
		n += 1 + sovCommands(uint64(m.Type))
	}
	if m.Mode != 0 {
		n += 1 + sovCommands(uint64(m.Mode))
	}
	return n
}

func (m *RpcObjectImportRequestParamsOfNotionParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NotionParams != nil {
		l = m.NotionParams.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}
func (m *RpcObjectImportRequestParamsOfBookmarksParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BookmarksParams != nil {
		l = m.BookmarksParams.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}
func (m *RpcObjectImportRequestParamsOfMarkdownParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MarkdownParams != nil {
		l = m.MarkdownParams.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}
func (m *RpcObjectImportRequestNotionParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ApiKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectImportRequestMarkdownParams) 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 *RpcObjectImportRequestBookmarksParams) 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 *RpcObjectImportRequestSnapshot) 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.Snapshot != nil {
		l = m.Snapshot.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectImportResponse) 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 *RpcObjectImportResponseError) 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 *RpcObjectImportNotion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectImportNotionTokenValidate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectImportNotionTokenValidateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ApiKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcObjectImportNotionTokenValidateResponse) 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 *RpcObjectImportNotionTokenValidateResponseError) 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 *RpcObjectImportList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectImportListRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectImportListResponse) 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.Response) > 0 {
		for _, e := range m.Response {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcObjectImportListResponseError) 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 *RpcObjectImportListImportResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovCommands(uint64(m.Type))
	}
	return n
}

func (m *RpcObjectRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = 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 len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			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))
	}
	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 *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))
	}
	if len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			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 *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 *RpcObjectRelationAddFeatured) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationAddFeaturedRequest) 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 *RpcObjectRelationAddFeaturedResponse) 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 *RpcObjectRelationAddFeaturedResponseError) 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 *RpcObjectRelationRemoveFeatured) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcObjectRelationRemoveFeaturedRequest) 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 *RpcObjectRelationRemoveFeaturedResponse) 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 *RpcObjectRelationRemoveFeaturedResponseError) 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 *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.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			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))
	}
	if len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			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 *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 *RpcRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcRelationListRemoveOption) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcRelationListRemoveOptionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.OptionIds) > 0 {
		for _, s := range m.OptionIds {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	if m.CheckInObjects {
		n += 2
	}
	return n
}

func (m *RpcRelationListRemoveOptionResponse) 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 *RpcRelationListRemoveOptionResponseError) 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 *RpcRelationOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcRelationOptionsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RelationKey)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcRelationOptionsResponse) 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.Options != nil {
		l = m.Options.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcRelationOptionsResponseError) 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 *RpcHistoryVersion) 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 *RpcHistoryGetVersions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcHistoryGetVersionsRequest) 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.LastVersionId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovCommands(uint64(m.Limit))
	}
	return n
}

func (m *RpcHistoryGetVersionsResponse) 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 *RpcHistoryGetVersionsResponseError) 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 *RpcHistoryShowVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcHistoryShowVersionRequest) 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.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 *RpcHistoryShowVersionResponse) 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.ObjectView != nil {
		l = m.ObjectView.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 *RpcHistoryShowVersionResponseError) 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.ObjectId)
	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 *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 *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 *RpcFileUpload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileUploadRequest) 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 *RpcFileUploadResponse) 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 *RpcFileUploadResponseError) 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 *RpcFileDownload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileDownloadRequest) 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 *RpcFileDownloadResponse) 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 *RpcFileDownloadResponseError) 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 *RpcFileDrop) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcFileDropRequest) 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 *RpcFileDropResponse) 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 *RpcFileDropResponseError) 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 *RpcTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcTemplateCreateFromObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcTemplateCreateFromObjectRequest) 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 *RpcTemplateCreateFromObjectResponse) 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 *RpcTemplateCreateFromObjectResponseError) 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 *RpcTemplateCreateFromObjectType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcTemplateCreateFromObjectTypeRequest) 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 *RpcTemplateCreateFromObjectTypeResponse) 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 *RpcTemplateCreateFromObjectTypeResponseError) 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 *RpcTemplateClone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcTemplateCloneRequest) 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 *RpcTemplateCloneResponse) 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 *RpcTemplateCloneResponseError) 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 *RpcTemplateExportAll) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcTemplateExportAllRequest) 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 *RpcTemplateExportAllResponse) 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 *RpcTemplateExportAllResponseError) 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 *RpcUnsplash) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = 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 *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 *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 *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 *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 *RpcBlockCreateWidget) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCreateWidgetRequest) 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))
	}
	if m.WidgetLayout != 0 {
		n += 1 + sovCommands(uint64(m.WidgetLayout))
	}
	return n
}

func (m *RpcBlockCreateWidgetResponse) 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 *RpcBlockCreateWidgetResponseError) 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 *RpcBlockListDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListDeleteRequest) 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 *RpcBlockListDeleteResponse) 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 *RpcBlockListDeleteResponseError) 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 *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 *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 *RpcBlockListSetVerticalAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListSetVerticalAlignRequest) 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.VerticalAlign != 0 {
		n += 1 + sovCommands(uint64(m.VerticalAlign))
	}
	return n
}

func (m *RpcBlockListSetVerticalAlignResponse) 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 *RpcBlockListSetVerticalAlignResponseError) 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 *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))
	}
	l = len(m.TargetContextId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	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 *RpcBlockListUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListUpdateRequest) 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.Field != nil {
		n += m.Field.Size()
	}
	return n
}

func (m *RpcBlockListUpdateRequestFieldOfText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Text != nil {
		l = m.Text.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}
func (m *RpcBlockListUpdateRequestFieldOfBackgroundColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BackgroundColor)
	n += 1 + l + sovCommands(uint64(l))
	return n
}
func (m *RpcBlockListUpdateRequestFieldOfAlign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovCommands(uint64(m.Align))
	return n
}
func (m *RpcBlockListUpdateRequestFieldOfFields) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fields != nil {
		l = m.Fields.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}
func (m *RpcBlockListUpdateRequestFieldOfDivStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovCommands(uint64(m.DivStyle))
	return n
}
func (m *RpcBlockListUpdateRequestFieldOfFileStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovCommands(uint64(m.FileStyle))
	return n
}
func (m *RpcBlockListUpdateRequestText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Field != nil {
		n += m.Field.Size()
	}
	return n
}

func (m *RpcBlockListUpdateRequestTextFieldOfStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovCommands(uint64(m.Style))
	return n
}
func (m *RpcBlockListUpdateRequestTextFieldOfColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Color)
	n += 1 + l + sovCommands(uint64(l))
	return n
}
func (m *RpcBlockListUpdateRequestTextFieldOfMark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mark != nil {
		l = m.Mark.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}
func (m *RpcBlockListConvertToObjects) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListConvertToObjectsRequest) 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 *RpcBlockListConvertToObjectsResponse) 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))
		}
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockListConvertToObjectsResponseError) 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 *RpcBlockListMoveToExistingObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListMoveToExistingObjectRequest) 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 *RpcBlockListMoveToExistingObjectResponse) 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 *RpcBlockListMoveToExistingObjectResponseError) 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 *RpcBlockListMoveToNewObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockListMoveToNewObjectRequest) 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 *RpcBlockListMoveToNewObjectResponse) 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 *RpcBlockListMoveToNewObjectResponseError) 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 *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 *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 *RpcBlockLatex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockLatexSetText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockLatexSetTextRequest) 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 *RpcBlockLatexSetTextResponse) 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 *RpcBlockLatexSetTextResponseError) 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 *RpcBlockText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetText) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetTextRequest) 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 *RpcBlockTextSetTextResponse) 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 *RpcBlockTextSetTextResponseError) 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 *RpcBlockTextSetColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetColorRequest) 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 *RpcBlockTextSetColorResponse) 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 *RpcBlockTextSetColorResponseError) 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 *RpcBlockTextSetMarks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetMarksGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetMarksGetRequest) 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 *RpcBlockTextSetMarksGetResponse) 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 *RpcBlockTextSetMarksGetResponseError) 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 *RpcBlockTextSetStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetStyleRequest) 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 *RpcBlockTextSetStyleResponse) 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 *RpcBlockTextSetStyleResponseError) 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 *RpcBlockTextSetChecked) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetCheckedRequest) 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 *RpcBlockTextSetCheckedResponse) 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 *RpcBlockTextSetCheckedResponseError) 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 *RpcBlockTextSetIcon) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextSetIconRequest) 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 *RpcBlockTextSetIconResponse) 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 *RpcBlockTextSetIconResponseError) 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 *RpcBlockTextListSetStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextListSetStyleRequest) 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 *RpcBlockTextListSetStyleResponse) 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 *RpcBlockTextListSetStyleResponseError) 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 *RpcBlockTextListSetColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextListSetColorRequest) 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 *RpcBlockTextListSetColorResponse) 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 *RpcBlockTextListSetColorResponseError) 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 *RpcBlockTextListSetMark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextListSetMarkRequest) 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 *RpcBlockTextListSetMarkResponse) 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 *RpcBlockTextListSetMarkResponseError) 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 *RpcBlockTextListClearStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextListClearStyleRequest) 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 *RpcBlockTextListClearStyleResponse) 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 *RpcBlockTextListClearStyleResponseError) 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 *RpcBlockTextListClearContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTextListClearContentRequest) 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 *RpcBlockTextListClearContentResponse) 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 *RpcBlockTextListClearContentResponseError) 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 *RpcBlockTable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableCreateRequest) 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))
	}
	if m.Rows != 0 {
		n += 1 + sovCommands(uint64(m.Rows))
	}
	if m.Columns != 0 {
		n += 1 + sovCommands(uint64(m.Columns))
	}
	if m.WithHeaderRow {
		n += 2
	}
	return n
}

func (m *RpcBlockTableCreateResponse) 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 *RpcBlockTableCreateResponseError) 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 *RpcBlockTableRowCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableRowCreateRequest) 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))
	}
	return n
}

func (m *RpcBlockTableRowCreateResponse) 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 *RpcBlockTableRowCreateResponseError) 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 *RpcBlockTableRowSetHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableRowSetHeaderRequest) 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.IsHeader {
		n += 2
	}
	return n
}

func (m *RpcBlockTableRowSetHeaderResponse) 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 *RpcBlockTableRowSetHeaderResponseError) 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 *RpcBlockTableRowListFill) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableRowListFillRequest) 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 *RpcBlockTableRowListFillResponse) 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 *RpcBlockTableRowListFillResponseError) 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 *RpcBlockTableRowListClean) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableRowListCleanRequest) 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 *RpcBlockTableRowListCleanResponse) 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 *RpcBlockTableRowListCleanResponseError) 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 *RpcBlockTableColumnListFill) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableColumnListFillRequest) 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 *RpcBlockTableColumnListFillResponse) 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 *RpcBlockTableColumnListFillResponseError) 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 *RpcBlockTableColumnCreate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableColumnCreateRequest) 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))
	}
	return n
}

func (m *RpcBlockTableColumnCreateResponse) 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 *RpcBlockTableColumnCreateResponseError) 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 *RpcBlockTableRowDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableRowDeleteRequest) 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))
	}
	return n
}

func (m *RpcBlockTableRowDeleteResponse) 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 *RpcBlockTableRowDeleteResponseError) 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 *RpcBlockTableColumnDelete) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableColumnDeleteRequest) 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))
	}
	return n
}

func (m *RpcBlockTableColumnDeleteResponse) 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 *RpcBlockTableColumnDeleteResponseError) 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 *RpcBlockTableColumnMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableColumnMoveRequest) 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))
	}
	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 *RpcBlockTableColumnMoveResponse) 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 *RpcBlockTableColumnMoveResponseError) 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 *RpcBlockTableRowDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableRowDuplicateRequest) 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))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockTableRowDuplicateResponse) 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 *RpcBlockTableRowDuplicateResponseError) 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 *RpcBlockTableColumnDuplicate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableColumnDuplicateRequest) 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))
	}
	l = len(m.BlockId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovCommands(uint64(m.Position))
	}
	return n
}

func (m *RpcBlockTableColumnDuplicateResponse) 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 *RpcBlockTableColumnDuplicateResponseError) 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 *RpcBlockTableExpand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableExpandRequest) 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.Columns != 0 {
		n += 1 + sovCommands(uint64(m.Columns))
	}
	if m.Rows != 0 {
		n += 1 + sovCommands(uint64(m.Rows))
	}
	return n
}

func (m *RpcBlockTableExpandResponse) 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 *RpcBlockTableExpandResponseError) 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 *RpcBlockTableSort) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockTableSortRequest) 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.ColumnId)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovCommands(uint64(m.Type))
	}
	return n
}

func (m *RpcBlockTableSortResponse) 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 *RpcBlockTableSortResponseError) 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 *RpcBlockFileSetName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockFileSetNameRequest) 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 *RpcBlockFileSetNameResponse) 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 *RpcBlockFileSetNameResponseError) 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 *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 *RpcBlockFileListSetStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockFileListSetStyleRequest) 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 *RpcBlockFileListSetStyleResponse) 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 *RpcBlockFileListSetStyleResponseError) 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 *RpcBlockImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockImageSetName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockImageSetNameRequest) 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 *RpcBlockImageSetNameResponse) 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 *RpcBlockImageSetNameResponseError) 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 *RpcBlockImageSetWidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockImageSetWidthRequest) 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 *RpcBlockImageSetWidthResponse) 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 *RpcBlockImageSetWidthResponseError) 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 *RpcBlockVideo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockVideoSetName) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockVideoSetNameRequest) 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 *RpcBlockVideoSetNameResponse) 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 *RpcBlockVideoSetNameResponseError) 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 *RpcBlockVideoSetWidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockVideoSetWidthRequest) 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 *RpcBlockVideoSetWidthResponse) 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 *RpcBlockVideoSetWidthResponseError) 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 *RpcBlockLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockLinkCreateWithObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockLinkCreateWithObjectRequest) 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))
	}
	if len(m.InternalFlags) > 0 {
		for _, e := range m.InternalFlags {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockLinkCreateWithObjectResponse) 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 *RpcBlockLinkCreateWithObjectResponseError) 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 *RpcBlockLinkListSetAppearance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockLinkListSetAppearanceRequest) 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.IconSize != 0 {
		n += 1 + sovCommands(uint64(m.IconSize))
	}
	if m.CardStyle != 0 {
		n += 1 + sovCommands(uint64(m.CardStyle))
	}
	if m.Description != 0 {
		n += 1 + sovCommands(uint64(m.Description))
	}
	if len(m.Relations) > 0 {
		for _, s := range m.Relations {
			l = len(s)
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockLinkListSetAppearanceResponse) 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 *RpcBlockLinkListSetAppearanceResponseError) 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))
	}
	l = len(m.RelationKey)
	if l > 0 {
		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 *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 *RpcBlockDiv) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDivListSetStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDivListSetStyleRequest) 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 *RpcBlockDivListSetStyleResponse) 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 *RpcBlockDivListSetStyleResponseError) 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 *RpcBlockDataviewView) 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 *RpcBlockDataviewRelation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = 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 len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			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))
	}
	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 *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))
	}
	if len(m.RelationKeys) > 0 {
		for _, s := range m.RelationKeys {
			l = len(s)
			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 *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 *RpcBlockDataviewGroupOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewGroupOrderUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewGroupOrderUpdateRequest) 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.GroupOrder != nil {
		l = m.GroupOrder.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockDataviewGroupOrderUpdateResponse) 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 *RpcBlockDataviewGroupOrderUpdateResponseError) 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 *RpcBlockDataviewObjectOrder) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewObjectOrderUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewObjectOrderUpdateRequest) 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.ObjectOrders) > 0 {
		for _, e := range m.ObjectOrders {
			l = e.Size()
			n += 1 + l + sovCommands(uint64(l))
		}
	}
	return n
}

func (m *RpcBlockDataviewObjectOrderUpdateResponse) 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 *RpcBlockDataviewObjectOrderUpdateResponseError) 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 *RpcBlockDataviewCreateBookmark) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockDataviewCreateBookmarkRequest) 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 *RpcBlockDataviewCreateBookmarkResponse) 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 *RpcBlockDataviewCreateBookmarkResponseError) 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.ObjectId)
	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
	}
	if m.GenerateSvg {
		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 *RpcDebugExportLocalstore) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDebugExportLocalstoreRequest) 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 *RpcDebugExportLocalstoreResponse) 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 *RpcDebugExportLocalstoreResponseError) 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 *RpcDebugPing) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcDebugPingRequest) 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 *RpcDebugPingResponse) 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 *RpcDebugPingResponseError) 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 *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 *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 *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 *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 (m *StreamRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(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 *RpcApp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: App: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: App: 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 *RpcAppGetVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetVersion: 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 *RpcAppGetVersionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcAppGetVersionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcAppGetVersionResponseError{}
			}
			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 *RpcAppGetVersionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcAppGetVersionResponseErrorCode(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 *RpcAppSetDeviceState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetDeviceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetDeviceState: 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 *RpcAppSetDeviceStateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 DeviceState", wireType)
			}
			m.DeviceState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeviceState |= RpcAppSetDeviceStateRequestDeviceState(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 *RpcAppSetDeviceStateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcAppSetDeviceStateResponseError{}
			}
			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 *RpcAppSetDeviceStateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcAppSetDeviceStateResponseErrorCode(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 *RpcAppShutdown) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcAppShutdownRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcAppShutdownResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcAppShutdownResponseError{}
			}
			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 *RpcAppShutdownResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcAppShutdownResponseErrorCode(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 *RpcWalletCreateSession) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateSession: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateSession: 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 *RpcWalletCreateSessionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWalletCreateSessionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcWalletCreateSessionResponseError{}
			}
			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 Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = 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 *RpcWalletCreateSessionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcWalletCreateSessionResponseErrorCode(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 *RpcWalletCloseSession) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CloseSession: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseSession: 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 *RpcWalletCloseSessionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = 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 *RpcWalletCloseSessionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcWalletCloseSessionResponseError{}
			}
			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 *RpcWalletCloseSessionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcWalletCloseSessionResponseErrorCode(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 EnablePrereleaseChannel", 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.EnablePrereleaseChannel = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableSpaces", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StorePath = 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 *RpcAccountDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcAccountDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 Revert", 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.Revert = 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 *RpcAccountDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcAccountDeleteResponseError{}
			}
			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 Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &model.AccountStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcAccountDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcAccountDeleteResponseErrorCode(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 *RpcAccountMove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcAccountMoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 NewPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewPath = 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 *RpcAccountMoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcAccountMoveResponseError{}
			}
			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 *RpcAccountMoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcAccountMoveResponseErrorCode(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 *RpcAccountConfigUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigUpdate: 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 *RpcAccountConfigUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 TimeZone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TimeZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IPFSStorageAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IPFSStorageAddr = 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 *RpcAccountConfigUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcAccountConfigUpdateResponseError{}
			}
			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 *RpcAccountConfigUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcAccountConfigUpdateResponseErrorCode(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 *RpcAccountGetConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetConfig: 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 *RpcAccountGetConfigGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcAccountGetConfigGetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *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 *RpcWorkspaceObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceObjectAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceObjectAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceObjectAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcWorkspaceObjectAddResponseError{}
			}
			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 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 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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcWorkspaceObjectAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcWorkspaceObjectAddResponseErrorCode(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 *RpcWorkspaceObjectListAdd) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListAdd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListAdd: 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 *RpcWorkspaceObjectListAddRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceObjectListAddResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcWorkspaceObjectListAddResponseError{}
			}
			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 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 *RpcWorkspaceObjectListAddResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcWorkspaceObjectListAddResponseErrorCode(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 *RpcWorkspaceObjectListRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListRemove: 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 *RpcWorkspaceObjectListRemoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceObjectListRemoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcWorkspaceObjectListRemoveResponseError{}
			}
			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 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 *RpcWorkspaceObjectListRemoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcWorkspaceObjectListRemoveResponseErrorCode(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 *RpcWorkspaceExport) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceExportRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcWorkspaceExportResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcWorkspaceExportResponseError{}
			}
			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 *RpcWorkspaceExportResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcWorkspaceExportResponseErrorCode(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 *RpcObjectOpen) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectOpenRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 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
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeRelationsAsDependentObjects", 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.IncludeRelationsAsDependentObjects = 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 *RpcObjectOpenResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectOpenResponseError{}
			}
			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 ObjectView", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectView == nil {
				m.ObjectView = &model.ObjectView{}
			}
			if err := m.ObjectView.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 *RpcObjectOpenResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectOpenResponseErrorCode(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 *RpcObjectClose) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectCloseRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 *RpcObjectCloseResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCloseResponseError{}
			}
			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 *RpcObjectCloseResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCloseResponseErrorCode(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 *RpcObjectShow) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectShowRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 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
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IncludeRelationsAsDependentObjects", 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.IncludeRelationsAsDependentObjects = 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 *RpcObjectShowResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectShowResponseError{}
			}
			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 ObjectView", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectView == nil {
				m.ObjectView = &model.ObjectView{}
			}
			if err := m.ObjectView.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 *RpcObjectShowResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectShowResponseErrorCode(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 *RpcObjectCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.InternalFlags = append(m.InternalFlags, &model.InternalFlag{})
			if err := m.InternalFlags[len(m.InternalFlags)-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 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 *RpcObjectCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCreateResponseError{}
			}
			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 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 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
		case 5:
			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 *RpcObjectCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCreateResponseErrorCode(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 *RpcObjectCreateBookmark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateBookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateBookmark: 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 *RpcObjectCreateBookmarkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectCreateBookmarkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCreateBookmarkResponseError{}
			}
			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 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 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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectCreateBookmarkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCreateBookmarkResponseErrorCode(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 *RpcObjectCreateRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateRelation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateRelation: 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 *RpcObjectCreateRelationRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectCreateRelationResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCreateRelationResponseError{}
			}
			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 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 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
		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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectCreateRelationResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCreateRelationResponseErrorCode(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 *RpcObjectCreateRelationOption) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateRelationOption: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateRelationOption: 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 *RpcObjectCreateRelationOptionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectCreateRelationOptionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCreateRelationOptionResponseError{}
			}
			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 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 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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectCreateRelationOptionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCreateRelationOptionResponseErrorCode(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 *RpcObjectCreateSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectCreateSetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.InternalFlags = append(m.InternalFlags, &model.InternalFlag{})
			if err := m.InternalFlags[len(m.InternalFlags)-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 *RpcObjectCreateSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCreateSetResponseError{}
			}
			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 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 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
		case 5:
			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 *RpcObjectCreateSetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCreateSetResponseErrorCode(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 *RpcObjectCreateObjectType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateObjectType: 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 *RpcObjectCreateObjectTypeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.InternalFlags = append(m.InternalFlags, &model.InternalFlag{})
			if err := m.InternalFlags[len(m.InternalFlags)-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 *RpcObjectCreateObjectTypeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectCreateObjectTypeResponseError{}
			}
			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 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 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 *RpcObjectCreateObjectTypeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectCreateObjectTypeResponseErrorCode(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 *RpcObjectBookmarkFetch) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BookmarkFetch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BookmarkFetch: 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 *RpcObjectBookmarkFetchRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 *RpcObjectBookmarkFetchResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectBookmarkFetchResponseError{}
			}
			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 *RpcObjectBookmarkFetchResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectBookmarkFetchResponseErrorCode(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 *RpcObjectToBookmark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ToBookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ToBookmark: 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 *RpcObjectToBookmarkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 *RpcObjectToBookmarkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectToBookmarkResponseError{}
			}
			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 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 *RpcObjectToBookmarkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectToBookmarkResponseErrorCode(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: 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 *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 *RpcObjectOpenBreadcrumbs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectOpenBreadcrumbsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectOpenBreadcrumbsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectOpenBreadcrumbsResponseError{}
			}
			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 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 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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectView", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectView == nil {
				m.ObjectView = &model.ObjectView{}
			}
			if err := m.ObjectView.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 *RpcObjectOpenBreadcrumbsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectOpenBreadcrumbsResponseErrorCode(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 *RpcObjectSetBreadcrumbs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectSetBreadcrumbsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectSetBreadcrumbsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectSetBreadcrumbsResponseError{}
			}
			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 *RpcObjectSetBreadcrumbsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectSetBreadcrumbsResponseErrorCode(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 *RpcObjectImportMarkdown) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectImportMarkdownRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectImportMarkdownResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectImportMarkdownResponseError{}
			}
			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 *RpcObjectImportMarkdownResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectImportMarkdownResponseErrorCode(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 *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 *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
		case 4:
			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 *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, &types.Struct{})
			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 *RpcObjectGroupsSubscribe) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GroupsSubscribe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupsSubscribe: 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 *RpcObjectGroupsSubscribeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 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 4:
			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 *RpcObjectGroupsSubscribeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectGroupsSubscribeResponseError{}
			}
			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 Groups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.Groups = append(m.Groups, &model.BlockContentDataviewGroup{})
			if err := m.Groups[len(m.Groups)-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 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 *RpcObjectGroupsSubscribeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectGroupsSubscribeResponseErrorCode(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 *RpcObjectSubscribeIds) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SubscribeIds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubscribeIds: 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 *RpcObjectSubscribeIdsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectSubscribeIdsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectSubscribeIdsResponseError{}
			}
			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 *RpcObjectSubscribeIdsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectSubscribeIdsResponseErrorCode(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 *RpcObjectSetObjectType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetObjectType: 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 *RpcObjectSetObjectTypeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectSetObjectTypeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectSetObjectTypeResponseError{}
			}
			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 *RpcObjectSetObjectTypeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectSetObjectTypeResponseErrorCode(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 *RpcObjectSetInternalFlags) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetInternalFlags: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetInternalFlags: 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 *RpcObjectSetInternalFlagsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.InternalFlags = append(m.InternalFlags, &model.InternalFlag{})
			if err := m.InternalFlags[len(m.InternalFlags)-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 *RpcObjectSetInternalFlagsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectSetInternalFlagsResponseError{}
			}
			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 *RpcObjectSetInternalFlagsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectSetInternalFlagsResponseErrorCode(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 *RpcObjectSetDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetDetails: 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 *RpcObjectSetDetailsDetail) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectSetDetailsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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, &RpcObjectSetDetailsDetail{})
			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 *RpcObjectSetDetailsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectSetDetailsResponseError{}
			}
			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 *RpcObjectSetDetailsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectSetDetailsResponseErrorCode(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 *RpcObjectUndoRedoCounter) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectUndo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectUndoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectUndoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectUndoResponseError{}
			}
			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 = &RpcObjectUndoRedoCounter{}
			}
			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 *RpcObjectUndoResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectUndoResponseErrorCode(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 *RpcObjectRedo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectRedoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectRedoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectRedoResponseError{}
			}
			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 = &RpcObjectUndoRedoCounter{}
			}
			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 *RpcObjectRedoResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectRedoResponseErrorCode(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 *RpcObjectListDuplicate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListDuplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListDuplicate: 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 *RpcObjectListDuplicateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectListDuplicateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectListDuplicateResponseError{}
			}
			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 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 *RpcObjectListDuplicateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectListDuplicateResponseErrorCode(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 *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: ListDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListDelete: 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 *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: ListSetIsArchived: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetIsArchived: 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: ListSetIsFavorite: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetIsFavorite: 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 *RpcObjectApplyTemplate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectApplyTemplateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectApplyTemplateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectApplyTemplateResponseError{}
			}
			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 *RpcObjectApplyTemplateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectApplyTemplateResponseErrorCode(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 *RpcObjectListExport) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListExport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListExport: 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 *RpcObjectListExportRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 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 |= RpcObjectListExportFormat(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 *RpcObjectListExportResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectListExportResponseError{}
			}
			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 *RpcObjectListExportResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectListExportResponseErrorCode(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 *RpcObjectImport) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Import: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Import: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcObjectImportRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 NotionParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RpcObjectImportRequestNotionParams{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Params = &RpcObjectImportRequestParamsOfNotionParams{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BookmarksParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RpcObjectImportRequestBookmarksParams{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Params = &RpcObjectImportRequestParamsOfBookmarksParams{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarkdownParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RpcObjectImportRequestMarkdownParams{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Params = &RpcObjectImportRequestParamsOfMarkdownParams{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snapshots", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.Snapshots = append(m.Snapshots, &RpcObjectImportRequestSnapshot{})
			if err := m.Snapshots[len(m.Snapshots)-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 UpdateExistingObjects", 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.UpdateExistingObjects = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= RpcObjectImportRequestType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 |= RpcObjectImportRequestMode(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 *RpcObjectImportRequestNotionParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NotionParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NotionParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApiKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApiKey = 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 *RpcObjectImportRequestMarkdownParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MarkdownParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MarkdownParams: 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 *RpcObjectImportRequestBookmarksParams) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BookmarksParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BookmarksParams: 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 *RpcObjectImportRequestSnapshot) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Snapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Snapshot: 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 Snapshot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Snapshot == nil {
				m.Snapshot = &model.SmartBlockSnapshotBase{}
			}
			if err := m.Snapshot.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 *RpcObjectImportResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectImportResponseError{}
			}
			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 *RpcObjectImportResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectImportResponseErrorCode(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 *RpcObjectImportNotion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Notion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Notion: 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 *RpcObjectImportNotionTokenValidate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TokenValidate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TokenValidate: 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 *RpcObjectImportNotionTokenValidateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ApiKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApiKey = 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 *RpcObjectImportNotionTokenValidateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectImportNotionTokenValidateResponseError{}
			}
			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 *RpcObjectImportNotionTokenValidateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectImportNotionTokenValidateResponseErrorCode(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 *RpcObjectImportList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ImportList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ImportList: 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 *RpcObjectImportListRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectImportListResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectImportListResponseError{}
			}
			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 Response", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.Response = append(m.Response, &RpcObjectImportListImportResponse{})
			if err := m.Response[len(m.Response)-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 *RpcObjectImportListResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectImportListResponseErrorCode(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 *RpcObjectImportListImportResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ImportResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ImportResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= RpcObjectImportListImportResponseType(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 *RpcObjectRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectRelation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectRelation: 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 *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: 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 *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 RelationKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKeys = append(m.RelationKeys, 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 *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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (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 *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: 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 *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 RelationKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKeys = append(m.RelationKeys, 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 *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: ListAvailable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListAvailable: 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 *RpcObjectRelationAddFeatured) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AddFeatured: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddFeatured: 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 *RpcObjectRelationAddFeaturedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectRelationAddFeaturedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectRelationAddFeaturedResponseError{}
			}
			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 *RpcObjectRelationAddFeaturedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectRelationAddFeaturedResponseErrorCode(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 *RpcObjectRelationRemoveFeatured) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveFeatured: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveFeatured: 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 *RpcObjectRelationRemoveFeaturedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcObjectRelationRemoveFeaturedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcObjectRelationRemoveFeaturedResponseError{}
			}
			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 *RpcObjectRelationRemoveFeaturedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcObjectRelationRemoveFeaturedResponseErrorCode(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 *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 RelationKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKeys = append(m.RelationKeys, 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 *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 RelationKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKeys = append(m.RelationKeys, 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 *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.RelationLink{})
			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 *RpcRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcRelationListRemoveOption) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListRemoveOption: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListRemoveOption: 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 *RpcRelationListRemoveOptionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 OptionIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OptionIds = append(m.OptionIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckInObjects", 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.CheckInObjects = 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 *RpcRelationListRemoveOptionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcRelationListRemoveOptionResponseError{}
			}
			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 *RpcRelationListRemoveOptionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcRelationListRemoveOptionResponseErrorCode(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 *RpcRelationOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Options: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Options: 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 *RpcRelationOptionsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 *RpcRelationOptionsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcRelationOptionsResponseError{}
			}
			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 Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Options == nil {
				m.Options = &model.RelationOptions{}
			}
			if err := m.Options.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 *RpcRelationOptionsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcRelationOptionsResponseErrorCode(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 *RpcHistoryVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcHistoryGetVersions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetVersions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetVersions: 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 *RpcHistoryGetVersionsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 *RpcHistoryGetVersionsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcHistoryGetVersionsResponseError{}
			}
			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, &RpcHistoryVersion{})
			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 *RpcHistoryGetVersionsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcHistoryGetVersionsResponseErrorCode(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 *RpcHistoryShowVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ShowVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShowVersion: 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 *RpcHistoryShowVersionRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 *RpcHistoryShowVersionResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcHistoryShowVersionResponseError{}
			}
			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 ObjectView", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectView == nil {
				m.ObjectView = &model.ObjectView{}
			}
			if err := m.ObjectView.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 = &RpcHistoryVersion{}
			}
			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 *RpcHistoryShowVersionResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcHistoryShowVersionResponseErrorCode(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 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 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 *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 *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: ListOffload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListOffload: 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 *RpcFileUpload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcFileUploadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcFileUploadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcFileUploadResponseError{}
			}
			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 *RpcFileUploadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcFileUploadResponseErrorCode(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 *RpcFileDownload) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcFileDownloadRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcFileDownloadResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcFileDownloadResponseError{}
			}
			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 *RpcFileDownloadResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcFileDownloadResponseErrorCode(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 *RpcFileDrop) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Drop: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Drop: 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 *RpcFileDropRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcFileDropResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcFileDropResponseError{}
			}
			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 *RpcFileDropResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcFileDropResponseErrorCode(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 *RpcTemplate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Template: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Template: 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 *RpcTemplateCreateFromObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateFromObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateFromObject: 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 *RpcTemplateCreateFromObjectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcTemplateCreateFromObjectResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcTemplateCreateFromObjectResponseError{}
			}
			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 *RpcTemplateCreateFromObjectResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcTemplateCreateFromObjectResponseErrorCode(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 *RpcTemplateCreateFromObjectType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateFromObjectType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateFromObjectType: 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 *RpcTemplateCreateFromObjectTypeRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcTemplateCreateFromObjectTypeResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcTemplateCreateFromObjectTypeResponseError{}
			}
			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 *RpcTemplateCreateFromObjectTypeResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcTemplateCreateFromObjectTypeResponseErrorCode(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 *RpcTemplateClone) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Clone: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Clone: 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 *RpcTemplateCloneRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcTemplateCloneResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcTemplateCloneResponseError{}
			}
			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 *RpcTemplateCloneResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcTemplateCloneResponseErrorCode(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 *RpcTemplateExportAll) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExportAll: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExportAll: 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 *RpcTemplateExportAllRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcTemplateExportAllResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcTemplateExportAllResponseError{}
			}
			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 *RpcTemplateExportAllResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcTemplateExportAllResponseErrorCode(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 *RpcUnsplash) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Unsplash: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Unsplash: 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 *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: 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 *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: 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 *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 *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 *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 *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 *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 *RpcBlockCreateWidget) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateWidget: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateWidget: 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 *RpcBlockCreateWidgetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WidgetLayout", wireType)
			}
			m.WidgetLayout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WidgetLayout |= model.BlockContentWidgetLayout(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 *RpcBlockCreateWidgetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockCreateWidgetResponseError{}
			}
			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 *RpcBlockCreateWidgetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockCreateWidgetResponseErrorCode(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 *RpcBlockListDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListDelete: 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 *RpcBlockListDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockListDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockListDeleteResponseError{}
			}
			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 *RpcBlockListDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockListDeleteResponseErrorCode(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 *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: SetFields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetFields: 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 *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: ListSetAlign: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetAlign: 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 *RpcBlockListSetVerticalAlign) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetVerticalAlign: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetVerticalAlign: 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 *RpcBlockListSetVerticalAlignRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 VerticalAlign", wireType)
			}
			m.VerticalAlign = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VerticalAlign |= model.BlockVerticalAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListSetVerticalAlignResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockListSetVerticalAlignResponseError{}
			}
			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 *RpcBlockListSetVerticalAlignResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockListSetVerticalAlignResponseErrorCode(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: ListSetFields: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetFields: 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 *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: ListDuplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListDuplicate: 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
				}
			}
		case 5:
			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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (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 *RpcBlockListUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListUpdate: 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 *RpcBlockListUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 Text", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RpcBlockListUpdateRequestText{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Field = &RpcBlockListUpdateRequestFieldOfText{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BackgroundColor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field = &RpcBlockListUpdateRequestFieldOfBackgroundColor{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Align", wireType)
			}
			var v model.BlockAlign
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= model.BlockAlign(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Field = &RpcBlockListUpdateRequestFieldOfAlign{v}
		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
			}
			v := &types.Struct{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Field = &RpcBlockListUpdateRequestFieldOfFields{v}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DivStyle", wireType)
			}
			var v model.BlockContentDivStyle
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= model.BlockContentDivStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Field = &RpcBlockListUpdateRequestFieldOfDivStyle{v}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileStyle", wireType)
			}
			var v model.BlockContentFileStyle
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= model.BlockContentFileStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Field = &RpcBlockListUpdateRequestFieldOfFileStyle{v}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListUpdateRequestText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Text: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Text: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
			}
			var v model.BlockContentTextStyle
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= model.BlockContentTextStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Field = &RpcBlockListUpdateRequestTextFieldOfStyle{v}
		case 2:
			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.Field = &RpcBlockListUpdateRequestTextFieldOfColor{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
			}
			v := &model.BlockContentTextMark{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Field = &RpcBlockListUpdateRequestTextFieldOfMark{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockListConvertToObjects) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListConvertToObjects: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListConvertToObjects: 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 *RpcBlockListConvertToObjectsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockListConvertToObjectsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockListConvertToObjectsResponseError{}
			}
			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
		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 *RpcBlockListConvertToObjectsResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockListConvertToObjectsResponseErrorCode(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 *RpcBlockListMoveToExistingObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListMoveToExistingObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListMoveToExistingObject: 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 *RpcBlockListMoveToExistingObjectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockListMoveToExistingObjectResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockListMoveToExistingObjectResponseError{}
			}
			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 *RpcBlockListMoveToExistingObjectResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockListMoveToExistingObjectResponseErrorCode(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 *RpcBlockListMoveToNewObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListMoveToNewObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListMoveToNewObject: 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 *RpcBlockListMoveToNewObjectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockListMoveToNewObjectResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockListMoveToNewObjectResponseError{}
			}
			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 *RpcBlockListMoveToNewObjectResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockListMoveToNewObjectResponseErrorCode(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: ListTurnInto: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListTurnInto: 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 *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: ListSetBackgroundColor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetBackgroundColor: 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 *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 *RpcBlockLatex) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockLatex: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockLatex: 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 *RpcBlockLatexSetText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetText: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetText: 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 *RpcBlockLatexSetTextRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockLatexSetTextResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockLatexSetTextResponseError{}
			}
			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 *RpcBlockLatexSetTextResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockLatexSetTextResponseErrorCode(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 *RpcBlockText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockText: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockText: 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 *RpcBlockTextSetText) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetText: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetText: 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 *RpcBlockTextSetTextRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetTextResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextSetTextResponseError{}
			}
			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 *RpcBlockTextSetTextResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextSetTextResponseErrorCode(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 *RpcBlockTextSetColor) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetColor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetColor: 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 *RpcBlockTextSetColorRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetColorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextSetColorResponseError{}
			}
			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 *RpcBlockTextSetColorResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextSetColorResponseErrorCode(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 *RpcBlockTextSetMarks) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetMarks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetMarks: 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 *RpcBlockTextSetMarksGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetMarksGetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetMarksGetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextSetMarksGetResponseError{}
			}
			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 *RpcBlockTextSetMarksGetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextSetMarksGetResponseErrorCode(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 *RpcBlockTextSetStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetStyle: 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 *RpcBlockTextSetStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextSetStyleResponseError{}
			}
			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 *RpcBlockTextSetStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextSetStyleResponseErrorCode(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 *RpcBlockTextSetChecked) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetChecked: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetChecked: 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 *RpcBlockTextSetCheckedRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetCheckedResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextSetCheckedResponseError{}
			}
			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 *RpcBlockTextSetCheckedResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextSetCheckedResponseErrorCode(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 *RpcBlockTextSetIcon) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetIcon: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetIcon: 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 *RpcBlockTextSetIconRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextSetIconResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextSetIconResponseError{}
			}
			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 *RpcBlockTextSetIconResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextSetIconResponseErrorCode(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 *RpcBlockTextListSetStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetStyle: 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 *RpcBlockTextListSetStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextListSetStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextListSetStyleResponseError{}
			}
			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 *RpcBlockTextListSetStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextListSetStyleResponseErrorCode(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 *RpcBlockTextListSetColor) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetColor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetColor: 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 *RpcBlockTextListSetColorRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextListSetColorResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextListSetColorResponseError{}
			}
			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 *RpcBlockTextListSetColorResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextListSetColorResponseErrorCode(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 *RpcBlockTextListSetMark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetMark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetMark: 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 *RpcBlockTextListSetMarkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextListSetMarkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextListSetMarkResponseError{}
			}
			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 *RpcBlockTextListSetMarkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextListSetMarkResponseErrorCode(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 *RpcBlockTextListClearStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListClearStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListClearStyle: 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 *RpcBlockTextListClearStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextListClearStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextListClearStyleResponseError{}
			}
			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 *RpcBlockTextListClearStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextListClearStyleResponseErrorCode(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 *RpcBlockTextListClearContent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListClearContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListClearContent: 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 *RpcBlockTextListClearContentRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTextListClearContentResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTextListClearContentResponseError{}
			}
			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 *RpcBlockTextListClearContentResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTextListClearContentResponseErrorCode(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 *RpcBlockTable) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockTable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockTable: 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 *RpcBlockTableCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTableCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
			}
			m.Rows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rows |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
			}
			m.Columns = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Columns |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithHeaderRow", 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.WithHeaderRow = 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 *RpcBlockTableCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableCreateResponseError{}
			}
			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 *RpcBlockTableCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableCreateResponseErrorCode(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 *RpcBlockTableRowCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowCreate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowCreate: 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 *RpcBlockTableRowCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockTableRowCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableRowCreateResponseError{}
			}
			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 *RpcBlockTableRowCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableRowCreateResponseErrorCode(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 *RpcBlockTableRowSetHeader) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowSetHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowSetHeader: 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 *RpcBlockTableRowSetHeaderRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 IsHeader", 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.IsHeader = 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 *RpcBlockTableRowSetHeaderResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableRowSetHeaderResponseError{}
			}
			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 *RpcBlockTableRowSetHeaderResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableRowSetHeaderResponseErrorCode(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 *RpcBlockTableRowListFill) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowListFill: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowListFill: 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 *RpcBlockTableRowListFillRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTableRowListFillResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableRowListFillResponseError{}
			}
			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 *RpcBlockTableRowListFillResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableRowListFillResponseErrorCode(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 *RpcBlockTableRowListClean) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowListClean: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowListClean: 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 *RpcBlockTableRowListCleanRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTableRowListCleanResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableRowListCleanResponseError{}
			}
			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 *RpcBlockTableRowListCleanResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableRowListCleanResponseErrorCode(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 *RpcBlockTableColumnListFill) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnListFill: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnListFill: 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 *RpcBlockTableColumnListFillRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockTableColumnListFillResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableColumnListFillResponseError{}
			}
			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 *RpcBlockTableColumnListFillResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableColumnListFillResponseErrorCode(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 *RpcBlockTableColumnCreate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnCreate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnCreate: 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 *RpcBlockTableColumnCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockTableColumnCreateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableColumnCreateResponseError{}
			}
			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 *RpcBlockTableColumnCreateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableColumnCreateResponseErrorCode(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 *RpcBlockTableRowDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowDelete: 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 *RpcBlockTableRowDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockTableRowDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableRowDeleteResponseError{}
			}
			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 *RpcBlockTableRowDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableRowDeleteResponseErrorCode(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 *RpcBlockTableColumnDelete) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnDelete: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnDelete: 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 *RpcBlockTableColumnDeleteRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockTableColumnDeleteResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableColumnDeleteResponseError{}
			}
			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 *RpcBlockTableColumnDeleteResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableColumnDeleteResponseErrorCode(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 *RpcBlockTableColumnMove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnMove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnMove: 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 *RpcBlockTableColumnMoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 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 *RpcBlockTableColumnMoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableColumnMoveResponseError{}
			}
			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 *RpcBlockTableColumnMoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableColumnMoveResponseErrorCode(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 *RpcBlockTableRowDuplicate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowDuplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowDuplicate: 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 *RpcBlockTableRowDuplicateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 != 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 *RpcBlockTableRowDuplicateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableRowDuplicateResponseError{}
			}
			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 *RpcBlockTableRowDuplicateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableRowDuplicateResponseErrorCode(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 *RpcBlockTableColumnDuplicate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnDuplicate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnDuplicate: 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 *RpcBlockTableColumnDuplicateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 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 != 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 *RpcBlockTableColumnDuplicateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableColumnDuplicateResponseError{}
			}
			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 *RpcBlockTableColumnDuplicateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableColumnDuplicateResponseErrorCode(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 *RpcBlockTableExpand) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Expand: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Expand: 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 *RpcBlockTableExpandRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 Columns", wireType)
			}
			m.Columns = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Columns |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
			}
			m.Rows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rows |= 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 *RpcBlockTableExpandResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableExpandResponseError{}
			}
			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 *RpcBlockTableExpandResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableExpandResponseErrorCode(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 *RpcBlockTableSort) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Sort: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sort: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockTableSortRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ColumnId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnId = 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.BlockContentDataviewSortType(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 *RpcBlockTableSortResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockTableSortResponseError{}
			}
			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 *RpcBlockTableSortResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockTableSortResponseErrorCode(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: BlockFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockFile: 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 *RpcBlockFileSetName) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetName: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetName: 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 *RpcBlockFileSetNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockFileSetNameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockFileSetNameResponseError{}
			}
			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 *RpcBlockFileSetNameResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockFileSetNameResponseErrorCode(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 *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 *RpcBlockFileListSetStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetStyle: 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 *RpcBlockFileListSetStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockFileListSetStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockFileListSetStyleResponseError{}
			}
			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 *RpcBlockFileListSetStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockFileListSetStyleResponseErrorCode(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 *RpcBlockImage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockImage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockImage: 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 *RpcBlockImageSetName) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetName: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetName: 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 *RpcBlockImageSetNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockImageSetNameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockImageSetNameResponseError{}
			}
			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 *RpcBlockImageSetNameResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockImageSetNameResponseErrorCode(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 *RpcBlockImageSetWidth) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetWidth: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetWidth: 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 *RpcBlockImageSetWidthRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockImageSetWidthResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockImageSetWidthResponseError{}
			}
			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 *RpcBlockImageSetWidthResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockImageSetWidthResponseErrorCode(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 *RpcBlockVideo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockVideo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockVideo: 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 *RpcBlockVideoSetName) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetName: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetName: 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 *RpcBlockVideoSetNameRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockVideoSetNameResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockVideoSetNameResponseError{}
			}
			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 *RpcBlockVideoSetNameResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockVideoSetNameResponseErrorCode(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 *RpcBlockVideoSetWidth) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetWidth: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetWidth: 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 *RpcBlockVideoSetWidthRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockVideoSetWidthResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockVideoSetWidthResponseError{}
			}
			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 *RpcBlockVideoSetWidthResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockVideoSetWidthResponseErrorCode(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 *RpcBlockLink) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockLink: 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 *RpcBlockLinkCreateWithObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateWithObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateWithObject: 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 *RpcBlockLinkCreateWithObjectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.InternalFlags = append(m.InternalFlags, &model.InternalFlag{})
			if err := m.InternalFlags[len(m.InternalFlags)-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 *RpcBlockLinkCreateWithObjectResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockLinkCreateWithObjectResponseError{}
			}
			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 *RpcBlockLinkCreateWithObjectResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockLinkCreateWithObjectResponseErrorCode(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 *RpcBlockLinkListSetAppearance) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetAppearance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetAppearance: 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 *RpcBlockLinkListSetAppearanceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IconSize", wireType)
			}
			m.IconSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IconSize |= model.BlockContentLinkIconSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CardStyle", wireType)
			}
			m.CardStyle = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CardStyle |= model.BlockContentLinkCardStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			m.Description = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Description |= model.BlockContentLinkDescription(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relations", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					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 *RpcBlockLinkListSetAppearanceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockLinkListSetAppearanceResponseError{}
			}
			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 *RpcBlockLinkListSetAppearanceResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockLinkListSetAppearanceResponseErrorCode(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: BlockRelation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockRelation: 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 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 *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 *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: BlockBookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockBookmark: 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 *RpcBlockDiv) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockDiv: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockDiv: 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 *RpcBlockDivListSetStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListSetStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListSetStyle: 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 *RpcBlockDivListSetStyleRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockDivListSetStyleResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockDivListSetStyleResponseError{}
			}
			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 *RpcBlockDivListSetStyleResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockDivListSetStyleResponseErrorCode(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: BlockDataview: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockDataview: 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 *RpcBlockDataviewView) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: View: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: View: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (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: 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 *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: 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 *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: 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 *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: SetPosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetPosition: 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: SetActive: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetActive: 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 *RpcBlockDataviewRelation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *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: 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 *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 RelationKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKeys = append(m.RelationKeys, 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 *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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (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 *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: 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 *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 RelationKeys", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelationKeys = append(m.RelationKeys, 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 *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: ListAvailable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListAvailable: 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 *RpcBlockDataviewGroupOrder) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GroupOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewGroupOrderUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockDataviewGroupOrderUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 GroupOrder", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GroupOrder == nil {
				m.GroupOrder = &model.BlockContentDataviewGroupOrder{}
			}
			if err := m.GroupOrder.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewGroupOrderUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockDataviewGroupOrderUpdateResponseError{}
			}
			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 *RpcBlockDataviewGroupOrderUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockDataviewGroupOrderUpdateResponseErrorCode(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 *RpcBlockDataviewObjectOrder) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectOrder: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectOrder: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockDataviewObjectOrderUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockDataviewObjectOrderUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 ObjectOrders", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << 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.ObjectOrders = append(m.ObjectOrders, &model.BlockContentDataviewObjectOrder{})
			if err := m.ObjectOrders[len(m.ObjectOrders)-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 *RpcBlockDataviewObjectOrderUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockDataviewObjectOrderUpdateResponseError{}
			}
			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 *RpcBlockDataviewObjectOrderUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockDataviewObjectOrderUpdateResponseErrorCode(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 *RpcBlockDataviewCreateBookmark) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CreateBookmark: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateBookmark: 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 *RpcBlockDataviewCreateBookmarkRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcBlockDataviewCreateBookmarkResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcBlockDataviewCreateBookmarkResponseError{}
			}
			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 *RpcBlockDataviewCreateBookmarkResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcBlockDataviewCreateBookmarkResponseErrorCode(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 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 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)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenerateSvg", 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.GenerateSvg = 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 *RpcDebugExportLocalstore) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcDebugExportLocalstoreRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcDebugExportLocalstoreResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcDebugExportLocalstoreResponseError{}
			}
			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 *RpcDebugExportLocalstoreResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcDebugExportLocalstoreResponseErrorCode(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 *RpcDebugPing) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcDebugPingRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 *RpcDebugPingResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 = &RpcDebugPingResponseError{}
			}
			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 *RpcDebugPingResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 |= RpcDebugPingResponseErrorCode(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 *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 *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 *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 *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 (m *StreamRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StreamRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = 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 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")
)