anytype-heart/pb/commands.pb.go

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

package pb

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	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 RpcBlockHistoryMoveResponseErrorCode int32

const (
	RpcBlockHistoryMoveResponseError_NULL          RpcBlockHistoryMoveResponseErrorCode = 0
	RpcBlockHistoryMoveResponseError_UNKNOWN_ERROR RpcBlockHistoryMoveResponseErrorCode = 1
	RpcBlockHistoryMoveResponseError_BAD_INPUT     RpcBlockHistoryMoveResponseErrorCode = 2
	RpcBlockHistoryMoveResponseError_CAN_NOT_MOVE  RpcBlockHistoryMoveResponseErrorCode = 3
)

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

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

func (x RpcBlockHistoryMoveResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockHistoryMoveResponseErrorCode_name, int32(x))
}

func (RpcBlockHistoryMoveResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 0, 0, 0, 1, 0, 0}
}

type RpcBlockOpenResponseErrorCode int32

const (
	RpcBlockOpenResponseError_NULL          RpcBlockOpenResponseErrorCode = 0
	RpcBlockOpenResponseError_UNKNOWN_ERROR RpcBlockOpenResponseErrorCode = 1
	RpcBlockOpenResponseError_BAD_INPUT     RpcBlockOpenResponseErrorCode = 2
)

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

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

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

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

type RpcBlockUpdateResponseErrorCode int32

const (
	RpcBlockUpdateResponseError_NULL          RpcBlockUpdateResponseErrorCode = 0
	RpcBlockUpdateResponseError_UNKNOWN_ERROR RpcBlockUpdateResponseErrorCode = 1
	RpcBlockUpdateResponseError_BAD_INPUT     RpcBlockUpdateResponseErrorCode = 2
)

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

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

func (x RpcBlockUpdateResponseErrorCode) String() string {
	return proto.EnumName(RpcBlockUpdateResponseErrorCode_name, int32(x))
}

func (RpcBlockUpdateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 0, 3, 1, 0, 0}
}

type RpcBlockCloseResponseErrorCode int32

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

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

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

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

func (RpcBlockCloseResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 0, 4, 1, 0, 0}
}

type RpcWalletCreateResponseErrorCode int32

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

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

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

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

func (RpcWalletCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []int{0, 1, 1, 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
)

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

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

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

func (RpcAccountCreateResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 2, 0, 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
)

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

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

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

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

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

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

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

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

type RpcVersionGetResponseErrorCode int32

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

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

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

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

func (RpcVersionGetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 4, 0, 1, 0, 0}
}

type RpcIpfsFileGetResponseErrorCode int32

const (
	RpcIpfsFileGetResponseError_NULL          RpcIpfsFileGetResponseErrorCode = 0
	RpcIpfsFileGetResponseError_UNKNOWN_ERROR RpcIpfsFileGetResponseErrorCode = 1
	RpcIpfsFileGetResponseError_BAD_INPUT     RpcIpfsFileGetResponseErrorCode = 2
	RpcIpfsFileGetResponseError_NOT_FOUND     RpcIpfsFileGetResponseErrorCode = 101
	RpcIpfsFileGetResponseError_TIMEOUT       RpcIpfsFileGetResponseErrorCode = 102
)

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

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

func (x RpcIpfsFileGetResponseErrorCode) String() string {
	return proto.EnumName(RpcIpfsFileGetResponseErrorCode_name, int32(x))
}

func (RpcIpfsFileGetResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 5, 0, 0, 1, 0, 0}
}

type RpcIpfsImageGetBlobResponseErrorCode int32

const (
	RpcIpfsImageGetBlobResponseError_NULL          RpcIpfsImageGetBlobResponseErrorCode = 0
	RpcIpfsImageGetBlobResponseError_UNKNOWN_ERROR RpcIpfsImageGetBlobResponseErrorCode = 1
	RpcIpfsImageGetBlobResponseError_BAD_INPUT     RpcIpfsImageGetBlobResponseErrorCode = 2
	RpcIpfsImageGetBlobResponseError_NOT_FOUND     RpcIpfsImageGetBlobResponseErrorCode = 101
	RpcIpfsImageGetBlobResponseError_TIMEOUT       RpcIpfsImageGetBlobResponseErrorCode = 102
)

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

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

func (x RpcIpfsImageGetBlobResponseErrorCode) String() string {
	return proto.EnumName(RpcIpfsImageGetBlobResponseErrorCode_name, int32(x))
}

func (RpcIpfsImageGetBlobResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 5, 1, 0, 0, 1, 0, 0}
}

type RpcIpfsImageGetFileResponseErrorCode int32

const (
	RpcIpfsImageGetFileResponseError_NULL          RpcIpfsImageGetFileResponseErrorCode = 0
	RpcIpfsImageGetFileResponseError_UNKNOWN_ERROR RpcIpfsImageGetFileResponseErrorCode = 1
	RpcIpfsImageGetFileResponseError_BAD_INPUT     RpcIpfsImageGetFileResponseErrorCode = 2
	RpcIpfsImageGetFileResponseError_NOT_FOUND     RpcIpfsImageGetFileResponseErrorCode = 101
	RpcIpfsImageGetFileResponseError_TIMEOUT       RpcIpfsImageGetFileResponseErrorCode = 102
)

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

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

func (x RpcIpfsImageGetFileResponseErrorCode) String() string {
	return proto.EnumName(RpcIpfsImageGetFileResponseErrorCode_name, int32(x))
}

func (RpcIpfsImageGetFileResponseErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 5, 1, 0, 1, 1, 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_0dff099eb2e3dfdb, []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

//
// Namespace, that agregates subtopics and actions, that relates to blocks.
type RpcBlock struct {
}

func (m *RpcBlock) Reset()         { *m = RpcBlock{} }
func (m *RpcBlock) String() string { return proto.CompactTextString(m) }
func (*RpcBlock) ProtoMessage()    {}
func (*RpcBlock) Descriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 0}
}
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

//
// Block history: switch between versions (lib context: switch block head), move forward or backward
// **Example scenario**
// 1. User -> MacOS Front: CMD+Z
// 2. Front -> MW: Rpc.Block.History.Move.Request(blockId, false)
// 3. MW -> Lib: ?? TODO
// 4. Lib: switches current block header to a previous one
// 5. Lib -> MW: prev version of block
// 6. MW -> Front: BlockShow(block.prevVersion)
type RpcBlockHistory struct {
}

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

var xxx_messageInfo_RpcBlockHistory proto.InternalMessageInfo

type RpcBlockHistoryMove struct {
}

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

var xxx_messageInfo_RpcBlockHistoryMove proto.InternalMessageInfo

type RpcBlockHistoryMoveRequest struct {
	BlockId     string `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
	MoveForward bool   `protobuf:"varint,2,opt,name=moveForward,proto3" json:"moveForward,omitempty"`
}

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

var xxx_messageInfo_RpcBlockHistoryMoveRequest proto.InternalMessageInfo

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

func (m *RpcBlockHistoryMoveRequest) GetMoveForward() bool {
	if m != nil {
		return m.MoveForward
	}
	return false
}

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

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

var xxx_messageInfo_RpcBlockHistoryMoveResponse proto.InternalMessageInfo

func (m *RpcBlockHistoryMoveResponse) GetError() *RpcBlockHistoryMoveResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockHistoryMoveResponseError proto.InternalMessageInfo

func (m *RpcBlockHistoryMoveResponseError) GetCode() RpcBlockHistoryMoveResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockHistoryMoveResponseError_NULL
}

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

//
// Works with a smart blocks (block-organizers, like page, dashboard etc)
// **Example scenario**
// 1A. On front-end start.
//     1. Front -> MW: Rpc.Block.Open.Request(dashboard.id)
//     2. MW -> Front: BlockShow(dashboard)
//     3. MW -> Front: Rpc.Block.Open.Response(err)
// 1B. User clicks on a page icon on the dashboard.
//     1. Front -> MW: Rpc.Block.Close.Request(dashboard.id)
// Get close response first, then open request:
//     2. MW -> Front: Rpc.Block.Close.Response(err)
//     3. Front -> MW: Rpc.Block.Open.Request(page.id)
//     4. MW -> Front: BlockShow(<page, blocks>)
//     5. MW -> Front: Rpc.Block.Open.Response(err)
// Image/Video/File blocks then:
//     6. MW -> Front: BlockShow(<blocks>)
type RpcBlockOpen struct {
}

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

var xxx_messageInfo_RpcBlockOpen proto.InternalMessageInfo

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

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

var xxx_messageInfo_RpcBlockOpenRequest proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_RpcBlockOpenResponse proto.InternalMessageInfo

func (m *RpcBlockOpenResponse) GetError() *RpcBlockOpenResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockOpenResponseError proto.InternalMessageInfo

func (m *RpcBlockOpenResponseError) GetCode() RpcBlockOpenResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockOpenResponseError_NULL
}

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

//
// 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(targetId:dashboard.id, position:after, 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(targetId:dashboard.id, position:after, 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_0dff099eb2e3dfdb, []int{0, 0, 2}
}
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

type RpcBlockCreateRequest struct {
	Block    *ModelBlock        `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
	TargetId string             `protobuf:"bytes,2,opt,name=targetId,proto3" json:"targetId,omitempty"`
	Position ModelBlockPosition `protobuf:"varint,3,opt,name=position,proto3,enum=anytype.ModelBlockPosition" 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_0dff099eb2e3dfdb, []int{0, 0, 2, 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) GetBlock() *ModelBlock {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *RpcBlockCreateRequest) GetTargetId() string {
	if m != nil {
		return m.TargetId
	}
	return ""
}

func (m *RpcBlockCreateRequest) GetPosition() ModelBlockPosition {
	if m != nil {
		return m.Position
	}
	return ModelBlock_BEFORE
}

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"`
}

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_0dff099eb2e3dfdb, []int{0, 0, 2, 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 ""
}

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_0dff099eb2e3dfdb, []int{0, 0, 2, 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 ""
}

//
// Update a Smart/Internal block. Request can contain a content/field/permission/children update
// **Example scenarios**
// Case A. Update text block on page
// 1. TODO
// Case B. Update page on dashboard
// 1. TODO
// Case C. Update page on page
// 1. TODO
// Case D. Update page permission on a dashboard
// 1. TODO
// Case E. Update page children of the same page
// 1. TODO
// Case F. Update children of a layout block on a page
// 1. TODO
type RpcBlockUpdate struct {
}

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

var xxx_messageInfo_RpcBlockUpdate proto.InternalMessageInfo

type RpcBlockUpdateRequest struct {
	Changes *ChangeMultipleBlocksList `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"`
}

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

var xxx_messageInfo_RpcBlockUpdateRequest proto.InternalMessageInfo

func (m *RpcBlockUpdateRequest) GetChanges() *ChangeMultipleBlocksList {
	if m != nil {
		return m.Changes
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockUpdateResponse proto.InternalMessageInfo

func (m *RpcBlockUpdateResponse) GetError() *RpcBlockUpdateResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockUpdateResponseError proto.InternalMessageInfo

func (m *RpcBlockUpdateResponseError) GetCode() RpcBlockUpdateResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockUpdateResponseError_NULL
}

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

//
// Block.Close – it means unsubscribe from a block.
// Precondition: block should be opened.
type RpcBlockClose struct {
}

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

var xxx_messageInfo_RpcBlockClose proto.InternalMessageInfo

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

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

var xxx_messageInfo_RpcBlockCloseRequest proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_RpcBlockCloseResponse proto.InternalMessageInfo

func (m *RpcBlockCloseResponse) GetError() *RpcBlockCloseResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_RpcBlockCloseResponseError proto.InternalMessageInfo

func (m *RpcBlockCloseResponseError) GetCode() RpcBlockCloseResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcBlockCloseResponseError_NULL
}

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

//
// Namespace, that agregates subtopics and actions, that relates to wallet.
type RpcWallet struct {
}

func (m *RpcWallet) Reset()         { *m = RpcWallet{} }
func (m *RpcWallet) String() string { return proto.CompactTextString(m) }
func (*RpcWallet) ProtoMessage()    {}
func (*RpcWallet) Descriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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_0dff099eb2e3dfdb, []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 ""
}

//
// Namespace, that agregates subtopics and actions, that relates to account.
type RpcAccount struct {
}

func (m *RpcAccount) Reset()         { *m = RpcAccount{} }
func (m *RpcAccount) String() string { return proto.CompactTextString(m) }
func (*RpcAccount) ProtoMessage()    {}
func (*RpcAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []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 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_0dff099eb2e3dfdb, []int{0, 2, 0}
}
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
	//	*RpcAccountCreateRequestAvatarOfAvatarColor
	Avatar isRpcAccountCreateRequestAvatar `protobuf_oneof:"avatar"`
}

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_0dff099eb2e3dfdb, []int{0, 2, 0, 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"`
}
type RpcAccountCreateRequestAvatarOfAvatarColor struct {
	AvatarColor string `protobuf:"bytes,3,opt,name=avatarColor,proto3,oneof" json:"avatarColor,omitempty"`
}

func (*RpcAccountCreateRequestAvatarOfAvatarLocalPath) isRpcAccountCreateRequestAvatar() {}
func (*RpcAccountCreateRequestAvatarOfAvatarColor) 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) GetAvatarColor() string {
	if x, ok := m.GetAvatar().(*RpcAccountCreateRequestAvatarOfAvatarColor); ok {
		return x.AvatarColor
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RpcAccountCreateRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RpcAccountCreateRequestAvatarOfAvatarLocalPath)(nil),
		(*RpcAccountCreateRequestAvatarOfAvatarColor)(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 *ModelAccount                  `protobuf:"bytes,2,opt,name=account,proto3" json:"account,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_0dff099eb2e3dfdb, []int{0, 2, 0, 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() *ModelAccount {
	if m != nil {
		return m.Account
	}
	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_0dff099eb2e3dfdb, []int{0, 2, 0, 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_0dff099eb2e3dfdb, []int{0, 2, 1}
}
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_0dff099eb2e3dfdb, []int{0, 2, 1, 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_0dff099eb2e3dfdb, []int{0, 2, 1, 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_0dff099eb2e3dfdb, []int{0, 2, 1, 1, 0}
}
func (m *RpcAccountRecoverResponseError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RpcAccountRecoverResponseError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RpcAccountRecoverResponseError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RpcAccountRecoverResponseError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RpcAccountRecoverResponseError.Merge(m, src)
}
func (m *RpcAccountRecoverResponseError) XXX_Size() int {
	return m.Size()
}
func (m *RpcAccountRecoverResponseError) XXX_DiscardUnknown() {
	xxx_messageInfo_RpcAccountRecoverResponseError.DiscardUnknown(m)
}

var xxx_messageInfo_RpcAccountRecoverResponseError proto.InternalMessageInfo

func (m *RpcAccountRecoverResponseError) GetCode() RpcAccountRecoverResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcAccountRecoverResponseError_NULL
}

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

type RpcAccountSelect struct {
}

func (m *RpcAccountSelect) Reset()         { *m = RpcAccountSelect{} }
func (m *RpcAccountSelect) String() string { return proto.CompactTextString(m) }
func (*RpcAccountSelect) ProtoMessage()    {}
func (*RpcAccountSelect) Descriptor() ([]byte, []int) {
	return fileDescriptor_0dff099eb2e3dfdb, []int{0, 2, 2}
}
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_0dff099eb2e3dfdb, []int{0, 2, 2, 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 *ModelAccount                  `protobuf:"bytes,2,opt,name=account,proto3" json:"account,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_0dff099eb2e3dfdb, []int{0, 2, 2, 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() *ModelAccount {
	if m != nil {
		return m.Account
	}
	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_0dff099eb2e3dfdb, []int{0, 2, 2, 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 ""
}

//
// Namespace, that agregates log subtopics and actions.
// Usage: send request with topic (Level) and description (message) from client to middleware to log.
type RpcLog struct {
}

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

var xxx_messageInfo_RpcLogSendResponseError proto.InternalMessageInfo

func (m *RpcLogSendResponseError) GetCode() RpcLogSendResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcLogSendResponseError_NULL
}

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

//
// Get info about a version of a middleware.
// Info is a string, that contains: BuildDate, GitCommit, GitBranch, GitState
type RpcVersion struct {
}

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

var xxx_messageInfo_RpcVersion proto.InternalMessageInfo

type RpcVersionGet struct {
}

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

var xxx_messageInfo_RpcVersionGet proto.InternalMessageInfo

type RpcVersionGetRequest struct {
}

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

var xxx_messageInfo_RpcVersionGetRequest proto.InternalMessageInfo

type RpcVersionGetResponse struct {
	Error   *RpcVersionGetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Version string                      `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_RpcVersionGetResponse proto.InternalMessageInfo

func (m *RpcVersionGetResponse) GetError() *RpcVersionGetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_RpcVersionGetResponseError proto.InternalMessageInfo

func (m *RpcVersionGetResponseError) GetCode() RpcVersionGetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcVersionGetResponseError_NULL
}

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

//
// Namespace, that agregates subtopics and actions to work with IPFS directly (get files, blobs, images, etc)
type RpcIpfs struct {
}

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

var xxx_messageInfo_RpcIpfs proto.InternalMessageInfo

type RpcIpfsFile struct {
}

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

var xxx_messageInfo_RpcIpfsFile proto.InternalMessageInfo

type RpcIpfsFileGet struct {
}

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

var xxx_messageInfo_RpcIpfsFileGet proto.InternalMessageInfo

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

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

var xxx_messageInfo_RpcIpfsFileGetRequest proto.InternalMessageInfo

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

type RpcIpfsFileGetResponse struct {
	Error *RpcIpfsFileGetResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Data  []byte                       `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	Media string                       `protobuf:"bytes,3,opt,name=media,proto3" json:"media,omitempty"`
	Name  string                       `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
}

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

var xxx_messageInfo_RpcIpfsFileGetResponse proto.InternalMessageInfo

func (m *RpcIpfsFileGetResponse) GetError() *RpcIpfsFileGetResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

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

func (m *RpcIpfsFileGetResponse) GetMedia() string {
	if m != nil {
		return m.Media
	}
	return ""
}

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

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

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

var xxx_messageInfo_RpcIpfsFileGetResponseError proto.InternalMessageInfo

func (m *RpcIpfsFileGetResponseError) GetCode() RpcIpfsFileGetResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcIpfsFileGetResponseError_NULL
}

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

type RpcIpfsImage struct {
}

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

var xxx_messageInfo_RpcIpfsImage proto.InternalMessageInfo

type RpcIpfsImageGet struct {
}

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

var xxx_messageInfo_RpcIpfsImageGet proto.InternalMessageInfo

type RpcIpfsImageGetBlob struct {
}

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

var xxx_messageInfo_RpcIpfsImageGetBlob proto.InternalMessageInfo

type RpcIpfsImageGetBlobRequest struct {
	Id    string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Size_ ModelImageSize `protobuf:"varint,2,opt,name=size,proto3,enum=anytype.ModelImageSize" json:"size,omitempty"`
}

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

var xxx_messageInfo_RpcIpfsImageGetBlobRequest proto.InternalMessageInfo

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

func (m *RpcIpfsImageGetBlobRequest) GetSize_() ModelImageSize {
	if m != nil {
		return m.Size_
	}
	return ModelImage_LARGE
}

type RpcIpfsImageGetBlobResponse struct {
	Error *RpcIpfsImageGetBlobResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Blob  []byte                            `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"`
}

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

var xxx_messageInfo_RpcIpfsImageGetBlobResponse proto.InternalMessageInfo

func (m *RpcIpfsImageGetBlobResponse) GetError() *RpcIpfsImageGetBlobResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcIpfsImageGetBlobResponse) GetBlob() []byte {
	if m != nil {
		return m.Blob
	}
	return nil
}

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

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

var xxx_messageInfo_RpcIpfsImageGetBlobResponseError proto.InternalMessageInfo

func (m *RpcIpfsImageGetBlobResponseError) GetCode() RpcIpfsImageGetBlobResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcIpfsImageGetBlobResponseError_NULL
}

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

type RpcIpfsImageGetFile struct {
}

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

var xxx_messageInfo_RpcIpfsImageGetFile proto.InternalMessageInfo

type RpcIpfsImageGetFileRequest struct {
	Id    string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Size_ ModelImageSize `protobuf:"varint,2,opt,name=size,proto3,enum=anytype.ModelImageSize" json:"size,omitempty"`
}

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

var xxx_messageInfo_RpcIpfsImageGetFileRequest proto.InternalMessageInfo

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

func (m *RpcIpfsImageGetFileRequest) GetSize_() ModelImageSize {
	if m != nil {
		return m.Size_
	}
	return ModelImage_LARGE
}

type RpcIpfsImageGetFileResponse struct {
	Error     *RpcIpfsImageGetFileResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	LocalPath string                            `protobuf:"bytes,2,opt,name=localPath,proto3" json:"localPath,omitempty"`
}

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

var xxx_messageInfo_RpcIpfsImageGetFileResponse proto.InternalMessageInfo

func (m *RpcIpfsImageGetFileResponse) GetError() *RpcIpfsImageGetFileResponseError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *RpcIpfsImageGetFileResponse) GetLocalPath() string {
	if m != nil {
		return m.LocalPath
	}
	return ""
}

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

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

var xxx_messageInfo_RpcIpfsImageGetFileResponseError proto.InternalMessageInfo

func (m *RpcIpfsImageGetFileResponseError) GetCode() RpcIpfsImageGetFileResponseErrorCode {
	if m != nil {
		return m.Code
	}
	return RpcIpfsImageGetFileResponseError_NULL
}

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

func init() {
	proto.RegisterEnum("anytype.RpcBlockHistoryMoveResponseErrorCode", RpcBlockHistoryMoveResponseErrorCode_name, RpcBlockHistoryMoveResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockOpenResponseErrorCode", RpcBlockOpenResponseErrorCode_name, RpcBlockOpenResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCreateResponseErrorCode", RpcBlockCreateResponseErrorCode_name, RpcBlockCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockUpdateResponseErrorCode", RpcBlockUpdateResponseErrorCode_name, RpcBlockUpdateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcBlockCloseResponseErrorCode", RpcBlockCloseResponseErrorCode_name, RpcBlockCloseResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWalletCreateResponseErrorCode", RpcWalletCreateResponseErrorCode_name, RpcWalletCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcWalletRecoverResponseErrorCode", RpcWalletRecoverResponseErrorCode_name, RpcWalletRecoverResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountCreateResponseErrorCode", RpcAccountCreateResponseErrorCode_name, RpcAccountCreateResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountRecoverResponseErrorCode", RpcAccountRecoverResponseErrorCode_name, RpcAccountRecoverResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcAccountSelectResponseErrorCode", RpcAccountSelectResponseErrorCode_name, RpcAccountSelectResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcLogSendRequestLevel", RpcLogSendRequestLevel_name, RpcLogSendRequestLevel_value)
	proto.RegisterEnum("anytype.RpcLogSendResponseErrorCode", RpcLogSendResponseErrorCode_name, RpcLogSendResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcVersionGetResponseErrorCode", RpcVersionGetResponseErrorCode_name, RpcVersionGetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcIpfsFileGetResponseErrorCode", RpcIpfsFileGetResponseErrorCode_name, RpcIpfsFileGetResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcIpfsImageGetBlobResponseErrorCode", RpcIpfsImageGetBlobResponseErrorCode_name, RpcIpfsImageGetBlobResponseErrorCode_value)
	proto.RegisterEnum("anytype.RpcIpfsImageGetFileResponseErrorCode", RpcIpfsImageGetFileResponseErrorCode_name, RpcIpfsImageGetFileResponseErrorCode_value)
	proto.RegisterType((*Rpc)(nil), "anytype.Rpc")
	proto.RegisterType((*RpcBlock)(nil), "anytype.Rpc.Block")
	proto.RegisterType((*RpcBlockHistory)(nil), "anytype.Rpc.Block.History")
	proto.RegisterType((*RpcBlockHistoryMove)(nil), "anytype.Rpc.Block.History.Move")
	proto.RegisterType((*RpcBlockHistoryMoveRequest)(nil), "anytype.Rpc.Block.History.Move.Request")
	proto.RegisterType((*RpcBlockHistoryMoveResponse)(nil), "anytype.Rpc.Block.History.Move.Response")
	proto.RegisterType((*RpcBlockHistoryMoveResponseError)(nil), "anytype.Rpc.Block.History.Move.Response.Error")
	proto.RegisterType((*RpcBlockOpen)(nil), "anytype.Rpc.Block.Open")
	proto.RegisterType((*RpcBlockOpenRequest)(nil), "anytype.Rpc.Block.Open.Request")
	proto.RegisterType((*RpcBlockOpenResponse)(nil), "anytype.Rpc.Block.Open.Response")
	proto.RegisterType((*RpcBlockOpenResponseError)(nil), "anytype.Rpc.Block.Open.Response.Error")
	proto.RegisterType((*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((*RpcBlockUpdate)(nil), "anytype.Rpc.Block.Update")
	proto.RegisterType((*RpcBlockUpdateRequest)(nil), "anytype.Rpc.Block.Update.Request")
	proto.RegisterType((*RpcBlockUpdateResponse)(nil), "anytype.Rpc.Block.Update.Response")
	proto.RegisterType((*RpcBlockUpdateResponseError)(nil), "anytype.Rpc.Block.Update.Response.Error")
	proto.RegisterType((*RpcBlockClose)(nil), "anytype.Rpc.Block.Close")
	proto.RegisterType((*RpcBlockCloseRequest)(nil), "anytype.Rpc.Block.Close.Request")
	proto.RegisterType((*RpcBlockCloseResponse)(nil), "anytype.Rpc.Block.Close.Response")
	proto.RegisterType((*RpcBlockCloseResponseError)(nil), "anytype.Rpc.Block.Close.Response.Error")
	proto.RegisterType((*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((*RpcAccount)(nil), "anytype.Rpc.Account")
	proto.RegisterType((*RpcAccountCreate)(nil), "anytype.Rpc.Account.Create")
	proto.RegisterType((*RpcAccountCreateRequest)(nil), "anytype.Rpc.Account.Create.Request")
	proto.RegisterType((*RpcAccountCreateResponse)(nil), "anytype.Rpc.Account.Create.Response")
	proto.RegisterType((*RpcAccountCreateResponseError)(nil), "anytype.Rpc.Account.Create.Response.Error")
	proto.RegisterType((*RpcAccountRecover)(nil), "anytype.Rpc.Account.Recover")
	proto.RegisterType((*RpcAccountRecoverRequest)(nil), "anytype.Rpc.Account.Recover.Request")
	proto.RegisterType((*RpcAccountRecoverResponse)(nil), "anytype.Rpc.Account.Recover.Response")
	proto.RegisterType((*RpcAccountRecoverResponseError)(nil), "anytype.Rpc.Account.Recover.Response.Error")
	proto.RegisterType((*RpcAccountSelect)(nil), "anytype.Rpc.Account.Select")
	proto.RegisterType((*RpcAccountSelectRequest)(nil), "anytype.Rpc.Account.Select.Request")
	proto.RegisterType((*RpcAccountSelectResponse)(nil), "anytype.Rpc.Account.Select.Response")
	proto.RegisterType((*RpcAccountSelectResponseError)(nil), "anytype.Rpc.Account.Select.Response.Error")
	proto.RegisterType((*RpcLog)(nil), "anytype.Rpc.Log")
	proto.RegisterType((*RpcLogSend)(nil), "anytype.Rpc.Log.Send")
	proto.RegisterType((*RpcLogSendRequest)(nil), "anytype.Rpc.Log.Send.Request")
	proto.RegisterType((*RpcLogSendResponse)(nil), "anytype.Rpc.Log.Send.Response")
	proto.RegisterType((*RpcLogSendResponseError)(nil), "anytype.Rpc.Log.Send.Response.Error")
	proto.RegisterType((*RpcVersion)(nil), "anytype.Rpc.Version")
	proto.RegisterType((*RpcVersionGet)(nil), "anytype.Rpc.Version.Get")
	proto.RegisterType((*RpcVersionGetRequest)(nil), "anytype.Rpc.Version.Get.Request")
	proto.RegisterType((*RpcVersionGetResponse)(nil), "anytype.Rpc.Version.Get.Response")
	proto.RegisterType((*RpcVersionGetResponseError)(nil), "anytype.Rpc.Version.Get.Response.Error")
	proto.RegisterType((*RpcIpfs)(nil), "anytype.Rpc.Ipfs")
	proto.RegisterType((*RpcIpfsFile)(nil), "anytype.Rpc.Ipfs.File")
	proto.RegisterType((*RpcIpfsFileGet)(nil), "anytype.Rpc.Ipfs.File.Get")
	proto.RegisterType((*RpcIpfsFileGetRequest)(nil), "anytype.Rpc.Ipfs.File.Get.Request")
	proto.RegisterType((*RpcIpfsFileGetResponse)(nil), "anytype.Rpc.Ipfs.File.Get.Response")
	proto.RegisterType((*RpcIpfsFileGetResponseError)(nil), "anytype.Rpc.Ipfs.File.Get.Response.Error")
	proto.RegisterType((*RpcIpfsImage)(nil), "anytype.Rpc.Ipfs.Image")
	proto.RegisterType((*RpcIpfsImageGet)(nil), "anytype.Rpc.Ipfs.Image.Get")
	proto.RegisterType((*RpcIpfsImageGetBlob)(nil), "anytype.Rpc.Ipfs.Image.Get.Blob")
	proto.RegisterType((*RpcIpfsImageGetBlobRequest)(nil), "anytype.Rpc.Ipfs.Image.Get.Blob.Request")
	proto.RegisterType((*RpcIpfsImageGetBlobResponse)(nil), "anytype.Rpc.Ipfs.Image.Get.Blob.Response")
	proto.RegisterType((*RpcIpfsImageGetBlobResponseError)(nil), "anytype.Rpc.Ipfs.Image.Get.Blob.Response.Error")
	proto.RegisterType((*RpcIpfsImageGetFile)(nil), "anytype.Rpc.Ipfs.Image.Get.File")
	proto.RegisterType((*RpcIpfsImageGetFileRequest)(nil), "anytype.Rpc.Ipfs.Image.Get.File.Request")
	proto.RegisterType((*RpcIpfsImageGetFileResponse)(nil), "anytype.Rpc.Ipfs.Image.Get.File.Response")
	proto.RegisterType((*RpcIpfsImageGetFileResponseError)(nil), "anytype.Rpc.Ipfs.Image.Get.File.Response.Error")
}

func init() { proto.RegisterFile("commands.proto", fileDescriptor_0dff099eb2e3dfdb) }

var fileDescriptor_0dff099eb2e3dfdb = []byte{
	// 1590 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0x4d, 0x8c, 0xdb, 0xd4,
	0x16, 0xc7, 0x27, 0x8e, 0xf3, 0x75, 0xe6, 0xe3, 0xb9, 0x56, 0x5f, 0xd5, 0xde, 0xd7, 0x37, 0xad,
	0xa6, 0xef, 0xf5, 0x4d, 0xa7, 0xad, 0x5b, 0x4d, 0xdf, 0x5b, 0xf4, 0x89, 0xd2, 0x3a, 0x89, 0x33,
	0x63, 0x48, 0xec, 0xe8, 0xc6, 0x99, 0x01, 0x36, 0x96, 0x27, 0xb9, 0x93, 0x09, 0x38, 0x71, 0x48,
	0xdc, 0xa9, 0xda, 0x1d, 0x2b, 0x90, 0x00, 0xa9, 0x20, 0xb1, 0x2a, 0xe2, 0x63, 0x0b, 0xad, 0xc4,
	0x06, 0x15, 0x21, 0x21, 0xa4, 0xc2, 0x02, 0x90, 0x90, 0x0a, 0x48, 0x08, 0x09, 0x81, 0x68, 0xbb,
	0x40, 0xa8, 0xb0, 0x64, 0x09, 0x42, 0xd7, 0x76, 0x12, 0x7b, 0x48, 0xd2, 0x78, 0xd4, 0x51, 0xd9,
	0xe5, 0xde, 0x39, 0x3e, 0xe7, 0xdc, 0xdf, 0xff, 0x9c, 0xfb, 0x31, 0x30, 0x53, 0xb1, 0x1a, 0x0d,
	0xa3, 0x59, 0xed, 0x08, 0xad, 0xb6, 0x65, 0x5b, 0x7c, 0xc2, 0x68, 0x5e, 0xb4, 0x2f, 0xb6, 0x08,
	0x9a, 0x6a, 0x58, 0x55, 0x62, 0x7a, 0xd3, 0x68, 0xba, 0xb2, 0x61, 0x34, 0x6b, 0xc4, 0x1b, 0xce,
	0x5d, 0x13, 0x20, 0x8a, 0x5b, 0x15, 0xf4, 0xdb, 0x14, 0xc4, 0xd2, 0xa6, 0x55, 0x79, 0x0a, 0xfd,
	0xc8, 0x40, 0x62, 0xb9, 0xde, 0xb1, 0xad, 0xf6, 0x45, 0xf4, 0x2d, 0x03, 0x6c, 0xc1, 0xda, 0x24,
	0x48, 0x82, 0x04, 0x26, 0x4f, 0x9f, 0x27, 0x1d, 0x9b, 0xdf, 0x0b, 0x89, 0x35, 0x6a, 0x28, 0x57,
	0xf7, 0x46, 0x0e, 0x46, 0xe6, 0x53, 0xb8, 0x3b, 0xe4, 0x0f, 0xc2, 0x64, 0xc3, 0xda, 0x24, 0x39,
	0xab, 0x7d, 0xc1, 0x68, 0x57, 0xf7, 0x32, 0x07, 0x23, 0xf3, 0x49, 0xec, 0x9f, 0x42, 0xcf, 0x33,
	0x90, 0xc4, 0xa4, 0xd3, 0xb2, 0x9a, 0x1d, 0xc2, 0x67, 0x21, 0x46, 0xda, 0x6d, 0xab, 0xed, 0xb8,
	0x99, 0x5c, 0x14, 0x04, 0x2f, 0x61, 0x01, 0xb7, 0x2a, 0x82, 0x93, 0x8b, 0xe0, 0xe5, 0x21, 0xd0,
	0x1c, 0x84, 0xee, 0x87, 0x82, 0x44, 0xbf, 0xc2, 0xee, 0xc7, 0xe8, 0xbd, 0x08, 0xc4, 0x9c, 0x09,
	0x7e, 0x09, 0xd8, 0x8a, 0x55, 0x25, 0x8e, 0xbb, 0x99, 0xc5, 0x53, 0xe1, 0xdc, 0x09, 0x19, 0xab,
	0x4a, 0xb0, 0xe3, 0x80, 0xae, 0xa3, 0x4a, 0x3a, 0x95, 0x76, 0xbd, 0x65, 0xd7, 0xad, 0xa6, 0xb3,
	0x8e, 0x14, 0xf6, 0x4f, 0xcd, 0x65, 0x81, 0xa5, 0xf6, 0x7c, 0x12, 0x58, 0xa5, 0x9c, 0xcf, 0x73,
	0x13, 0xfc, 0x2e, 0x98, 0x2e, 0x2b, 0x8f, 0x2a, 0xea, 0xaa, 0xa2, 0x4b, 0x18, 0xab, 0x98, 0x8b,
	0xf0, 0xd3, 0x90, 0x4a, 0x8b, 0x59, 0x5d, 0x56, 0x8a, 0x65, 0x8d, 0x63, 0x78, 0x0e, 0xa6, 0x32,
	0xa2, 0xa2, 0x2b, 0xaa, 0xa6, 0x17, 0xd4, 0x15, 0x89, 0x8b, 0xa2, 0x17, 0x19, 0x60, 0xd5, 0x16,
	0x69, 0xa2, 0x7d, 0x7d, 0xba, 0x33, 0xc0, 0xd4, 0xbb, 0x60, 0x99, 0x7a, 0x15, 0xfd, 0x14, 0xf1,
	0x11, 0x7b, 0x28, 0x48, 0xec, 0xf0, 0x80, 0x25, 0x52, 0x7f, 0x43, 0x48, 0xbd, 0xd6, 0x23, 0x75,
	0x36, 0x40, 0xea, 0xe8, 0x78, 0x6e, 0xc2, 0x11, 0x5a, 0x0c, 0x4f, 0x08, 0xbd, 0x19, 0x85, 0x78,
	0xa6, 0x4d, 0x0c, 0x9b, 0xa0, 0x17, 0x22, 0x7d, 0x24, 0x0b, 0x10, 0x73, 0x2a, 0xcc, 0x5b, 0xf5,
	0xee, 0x5e, 0xba, 0x05, 0x5a, 0xd7, 0x6e, 0xc2, 0xd8, 0x35, 0xe1, 0x11, 0x24, 0x6d, 0xa3, 0x5d,
	0x23, 0xb6, 0x5c, 0xf5, 0xb2, 0xea, 0x8d, 0xf9, 0xd3, 0x90, 0x6c, 0x59, 0x9d, 0xba, 0x93, 0x71,
	0xd4, 0x59, 0xf9, 0x3f, 0x07, 0xb9, 0x12, 0x8a, 0x9e, 0x11, 0xee, 0x99, 0xa3, 0x67, 0xfd, 0x75,
	0xfb, 0x70, 0x50, 0x85, 0xf9, 0x01, 0xf8, 0xdc, 0x55, 0x0c, 0xd6, 0xc1, 0xdf, 0x40, 0x4c, 0xa0,
	0x81, 0xd0, 0x1b, 0x3d, 0x85, 0xc4, 0x80, 0x42, 0xc7, 0xc7, 0x0d, 0xb1, 0xf3, 0x1a, 0xdd, 0x60,
	0x20, 0x5e, 0x6e, 0x55, 0xa9, 0x46, 0xcb, 0x7d, 0x89, 0xce, 0x40, 0xc2, 0xdb, 0x56, 0x3c, 0x28,
	0x87, 0x7a, 0x19, 0x67, 0x9c, 0x79, 0xa1, 0x70, 0xde, 0xb4, 0xeb, 0x2d, 0x93, 0xb8, 0xd9, 0x77,
	0xf2, 0xf5, 0x8e, 0x8d, 0xbb, 0xdf, 0xa0, 0x5f, 0x22, 0xe1, 0xf0, 0xba, 0x09, 0x0c, 0x29, 0xf3,
	0x30, 0x10, 0x07, 0x3a, 0xda, 0x79, 0x88, 0x97, 0x19, 0x88, 0x65, 0x4c, 0xab, 0x43, 0x46, 0x75,
	0xfe, 0x5d, 0x3f, 0x94, 0x33, 0x41, 0x28, 0xff, 0x19, 0x54, 0x10, 0xd4, 0xe1, 0x10, 0x26, 0xaf,
	0xf7, 0x98, 0x9c, 0x0b, 0x30, 0x39, 0x36, 0xa6, 0x9f, 0x9d, 0x47, 0xf2, 0x79, 0x0c, 0xe2, 0xab,
	0x86, 0x69, 0x12, 0x1b, 0x7d, 0xcf, 0xf4, 0xb6, 0x81, 0x7f, 0xf7, 0xf1, 0x20, 0x48, 0xb6, 0x2d,
	0xcb, 0x2e, 0x1a, 0xf6, 0x86, 0x07, 0xa9, 0x37, 0x46, 0x57, 0xfd, 0xed, 0x79, 0x36, 0x88, 0xea,
	0x48, 0x60, 0x89, 0x6e, 0x88, 0xd1, 0xfd, 0x89, 0x20, 0xd9, 0x68, 0x92, 0x86, 0xd5, 0xac, 0x57,
	0xba, 0x7b, 0x48, 0x77, 0x8c, 0x6e, 0xf4, 0x40, 0xa6, 0x03, 0x20, 0x85, 0xb1, 0xa3, 0x84, 0x43,
	0x59, 0xda, 0xc6, 0x41, 0x73, 0x00, 0xfe, 0x91, 0x13, 0xe5, 0xbc, 0x94, 0xd5, 0x35, 0x55, 0xcf,
	0x60, 0x49, 0xd4, 0x24, 0x3d, 0xaf, 0x66, 0xc4, 0xbc, 0x8e, 0xa5, 0xa2, 0xca, 0x11, 0x74, 0x8b,
	0xa1, 0x58, 0x2b, 0xd6, 0x26, 0x69, 0x23, 0x71, 0x2c, 0xc2, 0x23, 0x99, 0xbc, 0xec, 0xa7, 0x7f,
	0x2e, 0x48, 0x7f, 0x61, 0x10, 0x17, 0x2f, 0xf6, 0x90, 0x5a, 0xfd, 0xa8, 0x87, 0x38, 0x13, 0x40,
	0x7c, 0x62, 0x7c, 0x57, 0x7f, 0x01, 0xc6, 0x57, 0xa6, 0x20, 0x21, 0x56, 0x2a, 0xd6, 0xf9, 0xa6,
	0x8d, 0xde, 0x61, 0x7b, 0x05, 0x7d, 0xa1, 0x8f, 0x9b, 0x07, 0xb6, 0x69, 0x34, 0x88, 0x87, 0xda,
	0xf9, 0xcd, 0x2f, 0xc0, 0xdf, 0x8c, 0x4d, 0xc3, 0x36, 0xda, 0x79, 0xab, 0x62, 0x98, 0x8e, 0x12,
	0x4e, 0xc2, 0xcb, 0x13, 0x78, 0xeb, 0x1f, 0xf8, 0x39, 0x98, 0x74, 0xa7, 0x32, 0x96, 0x69, 0xb5,
	0x9d, 0x13, 0x8d, 0xda, 0xf9, 0x27, 0xd3, 0x49, 0x88, 0xbb, 0x43, 0x74, 0x35, 0x3a, 0xae, 0x48,
	0x5e, 0xd6, 0xa3, 0x7b, 0xe4, 0x24, 0x24, 0x0c, 0xd7, 0xce, 0x49, 0x70, 0x72, 0x71, 0xcf, 0x96,
	0xa3, 0xd4, 0xf3, 0x82, 0xbb, 0x66, 0xe8, 0x6d, 0x66, 0x1c, 0x59, 0x47, 0x06, 0x0f, 0x27, 0xeb,
	0xfb, 0x91, 0x6d, 0xe8, 0x7a, 0x0c, 0xe6, 0xc5, 0x4c, 0x46, 0x2d, 0x2b, 0x9a, 0xa7, 0x6a, 0x56,
	0x4f, 0x97, 0x35, 0xbd, 0xaf, 0x75, 0x49, 0x13, 0xb1, 0xa6, 0x2b, 0x6a, 0x56, 0xe2, 0xa8, 0x5c,
	0x87, 0xef, 0x61, 0x2d, 0x69, 0xba, 0x22, 0x16, 0x24, 0x6e, 0x7d, 0x0c, 0xcf, 0x92, 0xa6, 0x8b,
	0x2b, 0xa2, 0x26, 0x62, 0xae, 0x86, 0x3e, 0x8e, 0xf6, 0x5b, 0x34, 0xd5, 0xab, 0x19, 0x74, 0xcd,
	0xaf, 0xa2, 0x18, 0x54, 0xf1, 0xe8, 0x40, 0x90, 0xa3, 0x7b, 0xed, 0xbb, 0x9e, 0x28, 0xd9, 0x80,
	0x28, 0x27, 0x43, 0xf8, 0x0a, 0xa7, 0xca, 0xdd, 0xed, 0xa8, 0xf2, 0x77, 0xd8, 0xa5, 0xa8, 0xba,
	0x87, 0xaf, 0xa4, 0xe7, 0xd4, 0xb2, 0x92, 0xe5, 0x68, 0xb4, 0xfd, 0x8a, 0xe4, 0xc2, 0xc3, 0x52,
	0x46, 0x5d, 0x91, 0xb0, 0xbe, 0x2a, 0xe6, 0xf3, 0x92, 0xa6, 0xe7, 0x64, 0x5c, 0xd2, 0xb8, 0xf5,
	0x7b, 0xb5, 0x69, 0x8d, 0x3f, 0x04, 0x07, 0xfa, 0x63, 0x5d, 0x7a, 0x4c, 0x2e, 0x69, 0x25, 0x47,
	0x97, 0x8c, 0x8a, 0x71, 0xb9, 0xa8, 0x49, 0x59, 0x6e, 0x83, 0xdf, 0x03, 0x7c, 0xdf, 0x0b, 0x2e,
	0x2b, 0xae, 0xfc, 0x75, 0x1a, 0xdf, 0x8b, 0xd7, 0x0d, 0x4f, 0x2f, 0xf7, 0x45, 0x09, 0xe7, 0x54,
	0x5c, 0x90, 0xb2, 0xdc, 0x93, 0xe8, 0x15, 0x16, 0xe2, 0x25, 0x62, 0x92, 0x8a, 0x8d, 0xfe, 0x37,
	0xf4, 0xa4, 0x0f, 0x6c, 0xbc, 0xcc, 0x96, 0xa3, 0xed, 0xab, 0xd0, 0x7d, 0xeb, 0xc6, 0xbb, 0x6f,
	0x7d, 0xfb, 0x65, 0xa8, 0xbe, 0x1d, 0x18, 0x3c, 0x5c, 0x85, 0xdc, 0x8a, 0xec, 0xc0, 0x7e, 0x3c,
	0x8e, 0xd0, 0xeb, 0x43, 0x84, 0xae, 0x05, 0xbd, 0xe7, 0x64, 0x25, 0xdb, 0xad, 0x45, 0x5d, 0x56,
	0x72, 0x2a, 0xb7, 0xc1, 0x0b, 0xb0, 0xe0, 0xf3, 0x4e, 0xab, 0xc0, 0x8b, 0x20, 0x2a, 0x59, 0xbd,
	0xa0, 0x48, 0x05, 0x55, 0x91, 0x33, 0xce, 0x7c, 0x49, 0xd2, 0xb8, 0x3a, 0xfa, 0x30, 0x0a, 0xd1,
	0xbc, 0x55, 0x43, 0xd7, 0xa3, 0xc0, 0x96, 0x48, 0xb3, 0x8a, 0xde, 0x8a, 0x04, 0x1e, 0xd8, 0x0d,
	0xd2, 0xe9, 0x18, 0xb5, 0xee, 0xd9, 0xd0, 0x1d, 0xf2, 0xa7, 0x21, 0x66, 0x92, 0x4d, 0x62, 0x3a,
	0xd8, 0x66, 0x7c, 0x97, 0x6c, 0x2a, 0x41, 0xde, 0xaa, 0x09, 0xd4, 0x97, 0xe0, 0xf9, 0x11, 0xf2,
	0xd4, 0x14, 0xbb, 0x5f, 0xcc, 0x3d, 0x02, 0x31, 0x67, 0xcc, 0xa7, 0x20, 0x96, 0x95, 0xd2, 0xe5,
	0x25, 0x6e, 0x82, 0xfe, 0xec, 0xe2, 0x4c, 0x41, 0x2c, 0x27, 0x6a, 0x62, 0x9e, 0x63, 0x28, 0x76,
	0x67, 0x55, 0x51, 0x3a, 0x59, 0x14, 0x15, 0x39, 0xc3, 0xb1, 0xfc, 0x24, 0x24, 0x56, 0x45, 0xac,
	0xc8, 0xca, 0x12, 0x17, 0x43, 0xcf, 0xf8, 0x0f, 0xfc, 0xff, 0x07, 0x6b, 0xf2, 0x5f, 0xc3, 0x72,
	0x1a, 0xfd, 0x76, 0x3f, 0x13, 0xa8, 0xad, 0x23, 0xe3, 0x38, 0x09, 0x57, 0x55, 0xca, 0x36, 0x8a,
	0x6a, 0x1a, 0x52, 0x54, 0xb2, 0xee, 0x76, 0x33, 0x09, 0x09, 0x4d, 0x2e, 0x48, 0x6a, 0x59, 0xe3,
	0xd6, 0xd1, 0xd7, 0x0c, 0x24, 0x56, 0x48, 0xbb, 0x43, 0x5f, 0x87, 0x9f, 0x31, 0x10, 0x5d, 0x22,
	0xb6, 0x7f, 0xa3, 0xbe, 0xce, 0x8c, 0x7b, 0x79, 0xf7, 0x9c, 0x08, 0x4b, 0xc4, 0x1e, 0xfe, 0x5e,
	0xdc, 0x74, 0x8d, 0xba, 0xef, 0x45, 0x6f, 0x88, 0xbe, 0x18, 0xeb, 0x5a, 0x3f, 0x3c, 0x42, 0x38,
	0x84, 0xd5, 0x6d, 0x20, 0xdc, 0x0d, 0xdc, 0x8a, 0x84, 0x4b, 0xb2, 0xaa, 0xe8, 0x72, 0x49, 0x97,
	0x0a, 0x45, 0xed, 0x71, 0x2e, 0x3a, 0x12, 0xec, 0xab, 0x29, 0x60, 0xe5, 0xd6, 0x7a, 0x07, 0xfd,
	0xca, 0x00, 0x9b, 0xab, 0x9b, 0x04, 0xfd, 0xec, 0xe1, 0x1d, 0xf1, 0x56, 0xfa, 0x74, 0xec, 0x07,
	0x00, 0x75, 0x2d, 0x50, 0xb7, 0x23, 0x80, 0xf3, 0xc0, 0x56, 0x0d, 0xdb, 0x70, 0x18, 0x4c, 0x61,
	0xe7, 0x37, 0xbf, 0x1b, 0x62, 0x0d, 0x52, 0xad, 0x1b, 0xee, 0x3d, 0x0b, 0xbb, 0x83, 0xde, 0x1d,
	0x8e, 0xed, 0xdf, 0xe1, 0xd0, 0x07, 0x63, 0x3d, 0x11, 0x46, 0xe5, 0xf1, 0x60, 0x2b, 0xfb, 0x4a,
	0x1c, 0x62, 0x72, 0xc3, 0xa8, 0x11, 0xf4, 0x52, 0xdc, 0x05, 0xff, 0x3b, 0x03, 0x6c, 0xda, 0xb4,
	0xd6, 0xfc, 0x2f, 0xfe, 0xad, 0x67, 0xd8, 0x71, 0x60, 0x3b, 0xf5, 0x4b, 0xc4, 0xdb, 0x99, 0xf6,
	0x6d, 0x39, 0x55, 0x1c, 0x7f, 0x42, 0xa9, 0x7e, 0x89, 0x60, 0xc7, 0x8c, 0xde, 0x06, 0xfb, 0x82,
	0x49, 0x41, 0xc1, 0x4e, 0xfc, 0x19, 0x94, 0xfb, 0x3d, 0x25, 0x45, 0xf3, 0x18, 0x2e, 0xdb, 0x9a,
	0x69, 0xad, 0x75, 0x65, 0xa3, 0xbf, 0x7d, 0x8f, 0x89, 0xe5, 0x80, 0x18, 0xff, 0x0d, 0x19, 0xe3,
	0xc1, 0x4a, 0xf2, 0x5c, 0xd4, 0x6b, 0x85, 0xfb, 0x27, 0xc0, 0xbb, 0xdb, 0x15, 0xc0, 0xa9, 0xd9,
	0xc1, 0x02, 0xec, 0x87, 0x94, 0x19, 0x7c, 0xb7, 0xe0, 0xfe, 0xc4, 0xf6, 0xa4, 0x18, 0x10, 0xed,
	0x81, 0x4a, 0x91, 0xde, 0xff, 0xc9, 0xed, 0xd9, 0xc8, 0xcd, 0xdb, 0xb3, 0x91, 0x1f, 0x6e, 0xcf,
	0x46, 0x2e, 0xdf, 0x99, 0x9d, 0xb8, 0x79, 0x67, 0x76, 0xe2, 0x9b, 0x3b, 0xb3, 0x13, 0x4f, 0x30,
	0xad, 0xb5, 0xb5, 0xb8, 0xf3, 0x4f, 0xf5, 0x53, 0x7f, 0x04, 0x00, 0x00, 0xff, 0xff, 0xca, 0x53,
	0x5d, 0x79, 0x8c, 0x17, 0x00, 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 *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 *RpcBlockHistory) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockHistory) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockHistory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockHistoryMove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockHistoryMove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockHistoryMove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockHistoryMoveRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockHistoryMoveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockHistoryMoveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MoveForward {
		i--
		if m.MoveForward {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	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 *RpcBlockHistoryMoveResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockHistoryMoveResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockHistoryMoveResponse) 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 *RpcBlockHistoryMoveResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockHistoryMoveResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockHistoryMoveResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpen) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpen) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.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 *RpcBlockOpenResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockOpenResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockOpenResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockOpenResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *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] = 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 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] = 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 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 *RpcBlockUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Changes != nil {
		{
			size, err := m.Changes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockUpdateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateResponse) 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 *RpcBlockUpdateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockUpdateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockUpdateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockClose) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockClose) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockClose) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcBlockCloseRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCloseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCloseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.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 *RpcBlockCloseResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCloseResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCloseResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcBlockCloseResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcBlockCloseResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcBlockCloseResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *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 *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 *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 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 *RpcAccountCreateRequestAvatarOfAvatarColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreateRequestAvatarOfAvatarColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.AvatarColor)
	copy(dAtA[i:], m.AvatarColor)
	i = encodeVarintCommands(dAtA, i, uint64(len(m.AvatarColor)))
	i--
	dAtA[i] = 0x1a
	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.Account != nil {
		{
			size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountCreateResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountCreateResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountCreateResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecover) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecover) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecover) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecoverRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecoverRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecoverRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecoverResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecoverResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecoverResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountRecoverResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountRecoverResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountRecoverResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelect) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelect) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelect) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelectRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RootPath) > 0 {
		i -= len(m.RootPath)
		copy(dAtA[i:], m.RootPath)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.RootPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcAccountSelectResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcAccountSelectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcAccountSelectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.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 *RpcLog) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLog) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLog) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcLogSend) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcLogSendRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSendRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSendRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Level != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Level))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcLogSendResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSendResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSendResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcLogSendResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcLogSendResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcLogSendResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcVersion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcVersionGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcVersionGetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcVersionGetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x12
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcVersionGetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcVersionGetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcVersionGetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcIpfs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsFileGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsFileGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsFileGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsFileGetRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsFileGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsFileGetRequest) 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 *RpcIpfsFileGetResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsFileGetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsFileGetResponse) 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] = 0x22
	}
	if len(m.Media) > 0 {
		i -= len(m.Media)
		copy(dAtA[i:], m.Media)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Media)))
		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 m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCommands(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RpcIpfsFileGetResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsFileGetResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsFileGetResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcIpfsImage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsImageGet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsImageGetBlob) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetBlob) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetBlob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsImageGetBlobRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetBlobRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetBlobRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Size_ != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Size_))
		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 *RpcIpfsImageGetBlobResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetBlobResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetBlobResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Blob) > 0 {
		i -= len(m.Blob)
		copy(dAtA[i:], m.Blob)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Blob)))
		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 *RpcIpfsImageGetBlobResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetBlobResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetBlobResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RpcIpfsImageGetFile) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetFile) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *RpcIpfsImageGetFileRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetFileRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetFileRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Size_ != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Size_))
		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 *RpcIpfsImageGetFileResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetFileResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetFileResponse) 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 *RpcIpfsImageGetFileResponseError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RpcIpfsImageGetFileResponseError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RpcIpfsImageGetFileResponseError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintCommands(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintCommands(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	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 *RpcBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockHistory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockHistoryMove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockHistoryMoveRequest) 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.MoveForward {
		n += 2
	}
	return n
}

func (m *RpcBlockHistoryMoveResponse) Size() (n 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 *RpcBlockHistoryMoveResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpen) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockOpenRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockOpenResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *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
	if m.Block != nil {
		l = m.Block.Size()
		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 *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))
	}
	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 *RpcBlockUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Changes != nil {
		l = m.Changes.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockUpdateResponse) Size() (n 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 *RpcBlockUpdateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockClose) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcBlockCloseRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCloseResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcBlockCloseResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *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 *RpcAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = 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()
	}
	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 *RpcAccountCreateRequestAvatarOfAvatarColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AvatarColor)
	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))
	}
	return n
}

func (m *RpcAccountCreateResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountRecover) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountRecoverRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountRecoverResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountRecoverResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountSelect) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcAccountSelectRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.RootPath)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcAccountSelectResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	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 *RpcLog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcLogSend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcLogSendRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	if m.Level != 0 {
		n += 1 + sovCommands(uint64(m.Level))
	}
	return n
}

func (m *RpcLogSendResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcLogSendResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcVersion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcVersionGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcVersionGetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcVersionGetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcVersionGetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcIpfs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsFileGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsFileGetRequest) 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 *RpcIpfsFileGetResponse) Size() (n 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.Data)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	l = len(m.Media)
	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 *RpcIpfsFileGetResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcIpfsImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsImageGet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsImageGetBlob) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsImageGetBlobRequest) 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.Size_ != 0 {
		n += 1 + sovCommands(uint64(m.Size_))
	}
	return n
}

func (m *RpcIpfsImageGetBlobResponse) Size() (n 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.Blob)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcIpfsImageGetBlobResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCommands(uint64(l))
	}
	return n
}

func (m *RpcIpfsImageGetFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RpcIpfsImageGetFileRequest) 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.Size_ != 0 {
		n += 1 + sovCommands(uint64(m.Size_))
	}
	return n
}

func (m *RpcIpfsImageGetFileResponse) Size() (n 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 *RpcIpfsImageGetFileResponseError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovCommands(uint64(m.Code))
	}
	l = len(m.Description)
	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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockHistory) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockHistoryMove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockHistoryMoveRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MoveForward", 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.MoveForward = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockHistoryMoveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcBlockHistoryMoveResponseError{}
			}
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockHistoryMoveResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockHistoryMoveResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpen) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Open: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Open: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field 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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcBlockOpenResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockOpenResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockOpenResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 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 = &ModelBlock{}
			}
			if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field 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 |= ModelBlockPosition(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Changes == nil {
				m.Changes = &ChangeMultipleBlocksList{}
			}
			if err := m.Changes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcBlockUpdateResponseError{}
			}
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockUpdateResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockUpdateResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockClose) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Close: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Close: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCloseRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field 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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCloseResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcBlockCloseResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcBlockCloseResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcBlockCloseResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 AvatarColor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					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 = &RpcAccountCreateRequestAvatarOfAvatarColor{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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 = &ModelAccount{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 = &ModelAccount{}
			}
			if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Version: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Get: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Get: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcVersionGetResponseError{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcVersionGetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcVersionGetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Ipfs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ipfs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsFileGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsFileGetRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsFileGetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcIpfsFileGetResponseError{}
			}
			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 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 Media", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Media = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsFileGetResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcIpfsFileGetResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Image: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetBlob) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Blob: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Blob: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetBlobRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= ModelImageSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetBlobResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcIpfsImageGetBlobResponseError{}
			}
			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 Blob", 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.Blob = append(m.Blob[:0], dAtA[iNdEx:postIndex]...)
			if m.Blob == nil {
				m.Blob = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetBlobResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcIpfsImageGetBlobResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetFile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetFileRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: 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 Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= ModelImageSize(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetFileResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &RpcIpfsImageGetFileResponseError{}
			}
			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 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCommands
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RpcIpfsImageGetFileResponseError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCommands
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= RpcIpfsImageGetFileResponseErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCommands
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCommands
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCommands
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCommands(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCommands
			}
			if (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")
)