anytype-heart/pb/account.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: account.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 WalletCreateResponse_Error_Code int32

const (
	WalletCreateResponse_Error_NULL                        WalletCreateResponse_Error_Code = 0
	WalletCreateResponse_Error_UNKNOWN_ERROR               WalletCreateResponse_Error_Code = 1
	WalletCreateResponse_Error_BAD_INPUT                   WalletCreateResponse_Error_Code = 2
	WalletCreateResponse_Error_FAILED_TO_CREATE_LOCAL_REPO WalletCreateResponse_Error_Code = 101
)

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

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

func (x WalletCreateResponse_Error_Code) String() string {
	return proto.EnumName(WalletCreateResponse_Error_Code_name, int32(x))
}

func (WalletCreateResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e28828dcb8d24f0, []int{3, 0, 0}
}

type WalletRecoverResponse_Error_Code int32

const (
	WalletRecoverResponse_Error_NULL                        WalletRecoverResponse_Error_Code = 0
	WalletRecoverResponse_Error_UNKNOWN_ERROR               WalletRecoverResponse_Error_Code = 1
	WalletRecoverResponse_Error_BAD_INPUT                   WalletRecoverResponse_Error_Code = 2
	WalletRecoverResponse_Error_FAILED_TO_CREATE_LOCAL_REPO WalletRecoverResponse_Error_Code = 101
)

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

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

func (x WalletRecoverResponse_Error_Code) String() string {
	return proto.EnumName(WalletRecoverResponse_Error_Code_name, int32(x))
}

func (WalletRecoverResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e28828dcb8d24f0, []int{5, 0, 0}
}

type AccountCreateResponse_Error_Code int32

const (
	AccountCreateResponse_Error_NULL                                     AccountCreateResponse_Error_Code = 0
	AccountCreateResponse_Error_UNKNOWN_ERROR                            AccountCreateResponse_Error_Code = 1
	AccountCreateResponse_Error_BAD_INPUT                                AccountCreateResponse_Error_Code = 2
	AccountCreateResponse_Error_ACCOUNT_CREATED_BUT_FAILED_TO_START_NODE AccountCreateResponse_Error_Code = 101
	AccountCreateResponse_Error_ACCOUNT_CREATED_BUT_FAILED_TO_SET_NAME   AccountCreateResponse_Error_Code = 102
	AccountCreateResponse_Error_ACCOUNT_CREATED_BUT_FAILED_TO_SET_AVATAR AccountCreateResponse_Error_Code = 103
)

var AccountCreateResponse_Error_Code_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 AccountCreateResponse_Error_Code_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 AccountCreateResponse_Error_Code) String() string {
	return proto.EnumName(AccountCreateResponse_Error_Code_name, int32(x))
}

func (AccountCreateResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e28828dcb8d24f0, []int{7, 0, 0}
}

type AccountRecoverResponse_Error_Code int32

const (
	AccountRecoverResponse_Error_NULL          AccountRecoverResponse_Error_Code = 0
	AccountRecoverResponse_Error_UNKNOWN_ERROR AccountRecoverResponse_Error_Code = 1
	AccountRecoverResponse_Error_BAD_INPUT     AccountRecoverResponse_Error_Code = 2
	// ...
	AccountRecoverResponse_Error_NO_ACCOUNTS_FOUND               AccountRecoverResponse_Error_Code = 101
	AccountRecoverResponse_Error_NEED_TO_RECOVER_WALLET_FIRST    AccountRecoverResponse_Error_Code = 102
	AccountRecoverResponse_Error_FAILED_TO_CREATE_LOCAL_REPO     AccountRecoverResponse_Error_Code = 103
	AccountRecoverResponse_Error_LOCAL_REPO_EXISTS_BUT_CORRUPTED AccountRecoverResponse_Error_Code = 104
	AccountRecoverResponse_Error_FAILED_TO_RUN_NODE              AccountRecoverResponse_Error_Code = 105
)

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

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

func (x AccountRecoverResponse_Error_Code) String() string {
	return proto.EnumName(AccountRecoverResponse_Error_Code_name, int32(x))
}

func (AccountRecoverResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e28828dcb8d24f0, []int{9, 0, 0}
}

type AccountSelectResponse_Error_Code int32

const (
	AccountSelectResponse_Error_NULL                                       AccountSelectResponse_Error_Code = 0
	AccountSelectResponse_Error_UNKNOWN_ERROR                              AccountSelectResponse_Error_Code = 1
	AccountSelectResponse_Error_BAD_INPUT                                  AccountSelectResponse_Error_Code = 2
	AccountSelectResponse_Error_FAILED_TO_CREATE_LOCAL_REPO                AccountSelectResponse_Error_Code = 101
	AccountSelectResponse_Error_LOCAL_REPO_EXISTS_BUT_CORRUPTED            AccountSelectResponse_Error_Code = 102
	AccountSelectResponse_Error_FAILED_TO_RUN_NODE                         AccountSelectResponse_Error_Code = 103
	AccountSelectResponse_Error_FAILED_TO_FIND_ACCOUNT_INFO                AccountSelectResponse_Error_Code = 104
	AccountSelectResponse_Error_LOCAL_REPO_NOT_EXISTS_AND_MNEMONIC_NOT_SET AccountSelectResponse_Error_Code = 105
)

var AccountSelectResponse_Error_Code_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 AccountSelectResponse_Error_Code_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 AccountSelectResponse_Error_Code) String() string {
	return proto.EnumName(AccountSelectResponse_Error_Code_name, int32(x))
}

func (AccountSelectResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e28828dcb8d24f0, []int{11, 0, 0}
}

type AccountStartResponse_Error_Code int32

const (
	AccountStartResponse_Error_NULL                            AccountStartResponse_Error_Code = 0
	AccountStartResponse_Error_UNKNOWN_ERROR                   AccountStartResponse_Error_Code = 1
	AccountStartResponse_Error_BAD_INPUT                       AccountStartResponse_Error_Code = 2
	AccountStartResponse_Error_LOCAL_REPO_DOESNT_EXIST         AccountStartResponse_Error_Code = 101
	AccountStartResponse_Error_LOCAL_REPO_EXISTS_BUT_CORRUPTED AccountStartResponse_Error_Code = 102
	AccountStartResponse_Error_FAILED_TO_RUN_NODE              AccountStartResponse_Error_Code = 103
	AccountStartResponse_Error_FAILED_TO_FIND_ACCOUNT_INFO     AccountStartResponse_Error_Code = 104
)

var AccountStartResponse_Error_Code_name = map[int32]string{
	0:   "NULL",
	1:   "UNKNOWN_ERROR",
	2:   "BAD_INPUT",
	101: "LOCAL_REPO_DOESNT_EXIST",
	102: "LOCAL_REPO_EXISTS_BUT_CORRUPTED",
	103: "FAILED_TO_RUN_NODE",
	104: "FAILED_TO_FIND_ACCOUNT_INFO",
}

var AccountStartResponse_Error_Code_value = map[string]int32{
	"NULL":                            0,
	"UNKNOWN_ERROR":                   1,
	"BAD_INPUT":                       2,
	"LOCAL_REPO_DOESNT_EXIST":         101,
	"LOCAL_REPO_EXISTS_BUT_CORRUPTED": 102,
	"FAILED_TO_RUN_NODE":              103,
	"FAILED_TO_FIND_ACCOUNT_INFO":     104,
}

func (x AccountStartResponse_Error_Code) String() string {
	return proto.EnumName(AccountStartResponse_Error_Code_name, int32(x))
}

func (AccountStartResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8e28828dcb8d24f0, []int{13, 0, 0}
}

type Avatar struct {
	// Types that are valid to be assigned to Avatar:
	//	*Avatar_Image
	//	*Avatar_Color
	Avatar isAvatar_Avatar `protobuf_oneof:"avatar"`
}

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

var xxx_messageInfo_Avatar proto.InternalMessageInfo

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

type Avatar_Image struct {
	Image *Image `protobuf:"bytes,1,opt,name=image,proto3,oneof" json:"image,omitempty"`
}
type Avatar_Color struct {
	Color string `protobuf:"bytes,2,opt,name=color,proto3,oneof" json:"color,omitempty"`
}

func (*Avatar_Image) isAvatar_Avatar() {}
func (*Avatar_Color) isAvatar_Avatar() {}

func (m *Avatar) GetAvatar() isAvatar_Avatar {
	if m != nil {
		return m.Avatar
	}
	return nil
}

func (m *Avatar) GetImage() *Image {
	if x, ok := m.GetAvatar().(*Avatar_Image); ok {
		return x.Image
	}
	return nil
}

func (m *Avatar) GetColor() string {
	if x, ok := m.GetAvatar().(*Avatar_Color); ok {
		return x.Color
	}
	return ""
}

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

type Account struct {
	Id     string  `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name   string  `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Avatar *Avatar `protobuf:"bytes,3,opt,name=avatar,proto3" json:"avatar,omitempty"`
}

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

var xxx_messageInfo_Account proto.InternalMessageInfo

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

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

func (m *Account) GetAvatar() *Avatar {
	if m != nil {
		return m.Avatar
	}
	return nil
}

type WalletCreateRequest struct {
	RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"`
}

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

var xxx_messageInfo_WalletCreateRequest proto.InternalMessageInfo

func (m *WalletCreateRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

type WalletCreateResponse struct {
	Error    *WalletCreateResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Mnemonic string                      `protobuf:"bytes,2,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"`
}

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

var xxx_messageInfo_WalletCreateResponse proto.InternalMessageInfo

func (m *WalletCreateResponse) GetError() *WalletCreateResponse_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

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

var xxx_messageInfo_WalletCreateResponse_Error proto.InternalMessageInfo

func (m *WalletCreateResponse_Error) GetCode() WalletCreateResponse_Error_Code {
	if m != nil {
		return m.Code
	}
	return WalletCreateResponse_Error_NULL
}

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

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

var xxx_messageInfo_WalletRecoverRequest proto.InternalMessageInfo

func (m *WalletRecoverRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

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

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

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

var xxx_messageInfo_WalletRecoverResponse proto.InternalMessageInfo

func (m *WalletRecoverResponse) GetError() *WalletRecoverResponse_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_WalletRecoverResponse_Error proto.InternalMessageInfo

func (m *WalletRecoverResponse_Error) GetCode() WalletRecoverResponse_Error_Code {
	if m != nil {
		return m.Code
	}
	return WalletRecoverResponse_Error_NULL
}

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

type AccountCreateRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to Avatar:
	//	*AccountCreateRequest_AvatarLocalPath
	//	*AccountCreateRequest_AvatarColor
	Avatar isAccountCreateRequest_Avatar `protobuf_oneof:"avatar"`
}

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

var xxx_messageInfo_AccountCreateRequest proto.InternalMessageInfo

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

type AccountCreateRequest_AvatarLocalPath struct {
	AvatarLocalPath string `protobuf:"bytes,2,opt,name=avatarLocalPath,proto3,oneof" json:"avatarLocalPath,omitempty"`
}
type AccountCreateRequest_AvatarColor struct {
	AvatarColor string `protobuf:"bytes,3,opt,name=avatarColor,proto3,oneof" json:"avatarColor,omitempty"`
}

func (*AccountCreateRequest_AvatarLocalPath) isAccountCreateRequest_Avatar() {}
func (*AccountCreateRequest_AvatarColor) isAccountCreateRequest_Avatar()     {}

func (m *AccountCreateRequest) GetAvatar() isAccountCreateRequest_Avatar {
	if m != nil {
		return m.Avatar
	}
	return nil
}

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

func (m *AccountCreateRequest) GetAvatarLocalPath() string {
	if x, ok := m.GetAvatar().(*AccountCreateRequest_AvatarLocalPath); ok {
		return x.AvatarLocalPath
	}
	return ""
}

func (m *AccountCreateRequest) GetAvatarColor() string {
	if x, ok := m.GetAvatar().(*AccountCreateRequest_AvatarColor); ok {
		return x.AvatarColor
	}
	return ""
}

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

type AccountCreateResponse struct {
	Error   *AccountCreateResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Account *Account                     `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_AccountCreateResponse proto.InternalMessageInfo

func (m *AccountCreateResponse) GetError() *AccountCreateResponse_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *AccountCreateResponse) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

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

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

var xxx_messageInfo_AccountCreateResponse_Error proto.InternalMessageInfo

func (m *AccountCreateResponse_Error) GetCode() AccountCreateResponse_Error_Code {
	if m != nil {
		return m.Code
	}
	return AccountCreateResponse_Error_NULL
}

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

// Start accounts search for recovered mnemonic
type AccountRecoverRequest struct {
}

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

var xxx_messageInfo_AccountRecoverRequest proto.InternalMessageInfo

// Found accounts will come in event AccountAdd
type AccountRecoverResponse struct {
	Error *AccountRecoverResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_AccountRecoverResponse proto.InternalMessageInfo

func (m *AccountRecoverResponse) GetError() *AccountRecoverResponse_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

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

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

var xxx_messageInfo_AccountRecoverResponse_Error proto.InternalMessageInfo

func (m *AccountRecoverResponse_Error) GetCode() AccountRecoverResponse_Error_Code {
	if m != nil {
		return m.Code
	}
	return AccountRecoverResponse_Error_NULL
}

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

type AccountSelectRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// optional, set if this is the first request
	RootPath string `protobuf:"bytes,2,opt,name=rootPath,proto3" json:"rootPath,omitempty"`
}

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

var xxx_messageInfo_AccountSelectRequest proto.InternalMessageInfo

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

func (m *AccountSelectRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

type AccountSelectResponse struct {
	Error   *AccountSelectResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Account *Account                     `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_AccountSelectResponse proto.InternalMessageInfo

func (m *AccountSelectResponse) GetError() *AccountSelectResponse_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *AccountSelectResponse) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

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

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

var xxx_messageInfo_AccountSelectResponse_Error proto.InternalMessageInfo

func (m *AccountSelectResponse_Error) GetCode() AccountSelectResponse_Error_Code {
	if m != nil {
		return m.Code
	}
	return AccountSelectResponse_Error_NULL
}

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

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

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

var xxx_messageInfo_AccountStartRequest proto.InternalMessageInfo

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

type AccountStartResponse struct {
	Error   *AccountStartResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	Account *Account                    `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_AccountStartResponse proto.InternalMessageInfo

func (m *AccountStartResponse) GetError() *AccountStartResponse_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *AccountStartResponse) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

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

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

var xxx_messageInfo_AccountStartResponse_Error proto.InternalMessageInfo

func (m *AccountStartResponse_Error) GetCode() AccountStartResponse_Error_Code {
	if m != nil {
		return m.Code
	}
	return AccountStartResponse_Error_NULL
}

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

type AccountShow struct {
	Index   int64    `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Account *Account `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
}

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

var xxx_messageInfo_AccountShow proto.InternalMessageInfo

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

func (m *AccountShow) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

func init() {
	proto.RegisterEnum("anytype.WalletCreateResponse_Error_Code", WalletCreateResponse_Error_Code_name, WalletCreateResponse_Error_Code_value)
	proto.RegisterEnum("anytype.WalletRecoverResponse_Error_Code", WalletRecoverResponse_Error_Code_name, WalletRecoverResponse_Error_Code_value)
	proto.RegisterEnum("anytype.AccountCreateResponse_Error_Code", AccountCreateResponse_Error_Code_name, AccountCreateResponse_Error_Code_value)
	proto.RegisterEnum("anytype.AccountRecoverResponse_Error_Code", AccountRecoverResponse_Error_Code_name, AccountRecoverResponse_Error_Code_value)
	proto.RegisterEnum("anytype.AccountSelectResponse_Error_Code", AccountSelectResponse_Error_Code_name, AccountSelectResponse_Error_Code_value)
	proto.RegisterEnum("anytype.AccountStartResponse_Error_Code", AccountStartResponse_Error_Code_name, AccountStartResponse_Error_Code_value)
	proto.RegisterType((*Avatar)(nil), "anytype.Avatar")
	proto.RegisterType((*Account)(nil), "anytype.Account")
	proto.RegisterType((*WalletCreateRequest)(nil), "anytype.WalletCreateRequest")
	proto.RegisterType((*WalletCreateResponse)(nil), "anytype.WalletCreateResponse")
	proto.RegisterType((*WalletCreateResponse_Error)(nil), "anytype.WalletCreateResponse.Error")
	proto.RegisterType((*WalletRecoverRequest)(nil), "anytype.WalletRecoverRequest")
	proto.RegisterType((*WalletRecoverResponse)(nil), "anytype.WalletRecoverResponse")
	proto.RegisterType((*WalletRecoverResponse_Error)(nil), "anytype.WalletRecoverResponse.Error")
	proto.RegisterType((*AccountCreateRequest)(nil), "anytype.AccountCreateRequest")
	proto.RegisterType((*AccountCreateResponse)(nil), "anytype.AccountCreateResponse")
	proto.RegisterType((*AccountCreateResponse_Error)(nil), "anytype.AccountCreateResponse.Error")
	proto.RegisterType((*AccountRecoverRequest)(nil), "anytype.AccountRecoverRequest")
	proto.RegisterType((*AccountRecoverResponse)(nil), "anytype.AccountRecoverResponse")
	proto.RegisterType((*AccountRecoverResponse_Error)(nil), "anytype.AccountRecoverResponse.Error")
	proto.RegisterType((*AccountSelectRequest)(nil), "anytype.AccountSelectRequest")
	proto.RegisterType((*AccountSelectResponse)(nil), "anytype.AccountSelectResponse")
	proto.RegisterType((*AccountSelectResponse_Error)(nil), "anytype.AccountSelectResponse.Error")
	proto.RegisterType((*AccountStartRequest)(nil), "anytype.AccountStartRequest")
	proto.RegisterType((*AccountStartResponse)(nil), "anytype.AccountStartResponse")
	proto.RegisterType((*AccountStartResponse_Error)(nil), "anytype.AccountStartResponse.Error")
	proto.RegisterType((*AccountShow)(nil), "anytype.AccountShow")
}

func init() { proto.RegisterFile("account.proto", fileDescriptor_8e28828dcb8d24f0) }

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

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

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

func (m *Avatar) 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
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Avatar_Image) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Image != nil {
		{
			size, err := m.Image.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Avatar_Color) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Avatar_Color) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.Color)
	copy(dAtA[i:], m.Color)
	i = encodeVarintAccount(dAtA, i, uint64(len(m.Color)))
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}
func (m *Account) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *Account) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Avatar != nil {
		{
			size, err := m.Avatar.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAccount(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintAccount(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *WalletCreateRequest) 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 = encodeVarintAccount(dAtA, i, uint64(len(m.RootPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *WalletCreateResponse) 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 = encodeVarintAccount(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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *WalletRecoverRequest) 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 = encodeVarintAccount(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 = encodeVarintAccount(dAtA, i, uint64(len(m.RootPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *WalletRecoverResponse) 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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AccountCreateRequest) 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 = encodeVarintAccount(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AccountCreateRequest_AvatarLocalPath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.AvatarLocalPath)
	copy(dAtA[i:], m.AvatarLocalPath)
	i = encodeVarintAccount(dAtA, i, uint64(len(m.AvatarLocalPath)))
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}
func (m *AccountCreateRequest_AvatarColor) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccountCreateRequest_AvatarColor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.AvatarColor)
	copy(dAtA[i:], m.AvatarColor)
	i = encodeVarintAccount(dAtA, i, uint64(len(m.AvatarColor)))
	i--
	dAtA[i] = 0x1a
	return len(dAtA) - i, nil
}
func (m *AccountCreateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *AccountCreateResponse) 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 = encodeVarintAccount(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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *AccountRecoverResponse) 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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AccountSelectRequest) 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 = encodeVarintAccount(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 = encodeVarintAccount(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *AccountSelectResponse) 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 = encodeVarintAccount(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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AccountStartRequest) 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 = encodeVarintAccount(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *AccountStartResponse) 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 = encodeVarintAccount(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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AccountShow) 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 = encodeVarintAccount(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintAccount(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintAccount(dAtA []byte, offset int, v uint64) int {
	offset -= sovAccount(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Avatar) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Avatar != nil {
		n += m.Avatar.Size()
	}
	return n
}

func (m *Avatar_Image) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Image != nil {
		l = m.Image.Size()
		n += 1 + l + sovAccount(uint64(l))
	}
	return n
}
func (m *Avatar_Color) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Color)
	n += 1 + l + sovAccount(uint64(l))
	return n
}
func (m *Account) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovAccount(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAccount(uint64(l))
	}
	if m.Avatar != nil {
		l = m.Avatar.Size()
		n += 1 + l + sovAccount(uint64(l))
	}
	return n
}

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

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

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

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

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

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

func (m *AccountCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAccount(uint64(l))
	}
	if m.Avatar != nil {
		n += m.Avatar.Size()
	}
	return n
}

func (m *AccountCreateRequest_AvatarLocalPath) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AvatarLocalPath)
	n += 1 + l + sovAccount(uint64(l))
	return n
}
func (m *AccountCreateRequest_AvatarColor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AvatarColor)
	n += 1 + l + sovAccount(uint64(l))
	return n
}
func (m *AccountCreateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovAccount(uint64(l))
	}
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovAccount(uint64(l))
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

func (m *AccountShow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovAccount(uint64(m.Index))
	}
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovAccount(uint64(l))
	}
	return n
}

func sovAccount(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAccount(x uint64) (n int) {
	return sovAccount(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Avatar) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccount
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Avatar: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Avatar: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAccount
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Image{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Avatar = &Avatar_Image{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Avatar = &Avatar_Color{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccount(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccount
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccount
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccountCreateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAccount
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AccountCreateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccountCreateRequest: 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 ErrIntOverflowAccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccount
			}
			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 ErrIntOverflowAccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Avatar = &AccountCreateRequest_AvatarLocalPath{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 ErrIntOverflowAccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Avatar = &AccountCreateRequest_AvatarColor{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAccount(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAccount
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthAccount
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipAccount(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, ErrIntOverflowAccount
			}
			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, ErrIntOverflowAccount
				}
				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, ErrIntOverflowAccount
				}
				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, ErrInvalidLengthAccount
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupAccount
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthAccount
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthAccount        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAccount          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAccount = fmt.Errorf("proto: unexpected end of group")
)