bertyaccount.pb.go

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

package bertyaccount

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"

	_ "berty.tech/berty/v2/go/pkg/errcode"
	protocoltypes "berty.tech/berty/v2/go/pkg/protocoltypes"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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 OpenAccount struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenAccount) Reset()         { *m = OpenAccount{} }
func (m *OpenAccount) String() string { return proto.CompactTextString(m) }
func (*OpenAccount) ProtoMessage()    {}
func (*OpenAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{0}
}

func (m *OpenAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OpenAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *OpenAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenAccount.Merge(m, src)
}

func (m *OpenAccount) XXX_Size() int {
	return m.Size()
}

func (m *OpenAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenAccount.DiscardUnknown(m)
}

var xxx_messageInfo_OpenAccount proto.InternalMessageInfo

type OpenAccount_Request struct {
	Args                 []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
	AccountID            string   `protobuf:"bytes,2,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	LoggerFilters        string   `protobuf:"bytes,3,opt,name=logger_filters,json=loggerFilters,proto3" json:"logger_filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenAccount_Request) Reset()         { *m = OpenAccount_Request{} }
func (m *OpenAccount_Request) String() string { return proto.CompactTextString(m) }
func (*OpenAccount_Request) ProtoMessage()    {}
func (*OpenAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{0, 0}
}

func (m *OpenAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OpenAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenAccount_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *OpenAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenAccount_Request.Merge(m, src)
}

func (m *OpenAccount_Request) XXX_Size() int {
	return m.Size()
}

func (m *OpenAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_OpenAccount_Request proto.InternalMessageInfo

func (m *OpenAccount_Request) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *OpenAccount_Request) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

func (m *OpenAccount_Request) GetLoggerFilters() string {
	if m != nil {
		return m.LoggerFilters
	}
	return ""
}

type OpenAccount_Reply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenAccount_Reply) Reset()         { *m = OpenAccount_Reply{} }
func (m *OpenAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*OpenAccount_Reply) ProtoMessage()    {}
func (*OpenAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{0, 1}
}

func (m *OpenAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OpenAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenAccount_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *OpenAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenAccount_Reply.Merge(m, src)
}

func (m *OpenAccount_Reply) XXX_Size() int {
	return m.Size()
}

func (m *OpenAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_OpenAccount_Reply proto.InternalMessageInfo

type OpenAccountWithProgress struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenAccountWithProgress) Reset()         { *m = OpenAccountWithProgress{} }
func (m *OpenAccountWithProgress) String() string { return proto.CompactTextString(m) }
func (*OpenAccountWithProgress) ProtoMessage()    {}
func (*OpenAccountWithProgress) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{1}
}

func (m *OpenAccountWithProgress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OpenAccountWithProgress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenAccountWithProgress.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *OpenAccountWithProgress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenAccountWithProgress.Merge(m, src)
}

func (m *OpenAccountWithProgress) XXX_Size() int {
	return m.Size()
}

func (m *OpenAccountWithProgress) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenAccountWithProgress.DiscardUnknown(m)
}

var xxx_messageInfo_OpenAccountWithProgress proto.InternalMessageInfo

type OpenAccountWithProgress_Request struct {
	Args                 []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
	AccountID            string   `protobuf:"bytes,2,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	LoggerFilters        string   `protobuf:"bytes,3,opt,name=logger_filters,json=loggerFilters,proto3" json:"logger_filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenAccountWithProgress_Request) Reset()         { *m = OpenAccountWithProgress_Request{} }
func (m *OpenAccountWithProgress_Request) String() string { return proto.CompactTextString(m) }
func (*OpenAccountWithProgress_Request) ProtoMessage()    {}
func (*OpenAccountWithProgress_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{1, 0}
}

func (m *OpenAccountWithProgress_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OpenAccountWithProgress_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenAccountWithProgress_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *OpenAccountWithProgress_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenAccountWithProgress_Request.Merge(m, src)
}

func (m *OpenAccountWithProgress_Request) XXX_Size() int {
	return m.Size()
}

func (m *OpenAccountWithProgress_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenAccountWithProgress_Request.DiscardUnknown(m)
}

var xxx_messageInfo_OpenAccountWithProgress_Request proto.InternalMessageInfo

func (m *OpenAccountWithProgress_Request) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *OpenAccountWithProgress_Request) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

func (m *OpenAccountWithProgress_Request) GetLoggerFilters() string {
	if m != nil {
		return m.LoggerFilters
	}
	return ""
}

type OpenAccountWithProgress_Reply struct {
	Progress             *protocoltypes.Progress `protobuf:"bytes,1,opt,name=progress,proto3" json:"progress,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *OpenAccountWithProgress_Reply) Reset()         { *m = OpenAccountWithProgress_Reply{} }
func (m *OpenAccountWithProgress_Reply) String() string { return proto.CompactTextString(m) }
func (*OpenAccountWithProgress_Reply) ProtoMessage()    {}
func (*OpenAccountWithProgress_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{1, 1}
}

func (m *OpenAccountWithProgress_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OpenAccountWithProgress_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OpenAccountWithProgress_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *OpenAccountWithProgress_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenAccountWithProgress_Reply.Merge(m, src)
}

func (m *OpenAccountWithProgress_Reply) XXX_Size() int {
	return m.Size()
}

func (m *OpenAccountWithProgress_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenAccountWithProgress_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_OpenAccountWithProgress_Reply proto.InternalMessageInfo

func (m *OpenAccountWithProgress_Reply) GetProgress() *protocoltypes.Progress {
	if m != nil {
		return m.Progress
	}
	return nil
}

type CloseAccount struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseAccount) Reset()         { *m = CloseAccount{} }
func (m *CloseAccount) String() string { return proto.CompactTextString(m) }
func (*CloseAccount) ProtoMessage()    {}
func (*CloseAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{2}
}

func (m *CloseAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CloseAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CloseAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseAccount.Merge(m, src)
}

func (m *CloseAccount) XXX_Size() int {
	return m.Size()
}

func (m *CloseAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseAccount.DiscardUnknown(m)
}

var xxx_messageInfo_CloseAccount proto.InternalMessageInfo

type CloseAccount_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseAccount_Request) Reset()         { *m = CloseAccount_Request{} }
func (m *CloseAccount_Request) String() string { return proto.CompactTextString(m) }
func (*CloseAccount_Request) ProtoMessage()    {}
func (*CloseAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{2, 0}
}

func (m *CloseAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CloseAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseAccount_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CloseAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseAccount_Request.Merge(m, src)
}

func (m *CloseAccount_Request) XXX_Size() int {
	return m.Size()
}

func (m *CloseAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_CloseAccount_Request proto.InternalMessageInfo

type CloseAccount_Reply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseAccount_Reply) Reset()         { *m = CloseAccount_Reply{} }
func (m *CloseAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*CloseAccount_Reply) ProtoMessage()    {}
func (*CloseAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{2, 1}
}

func (m *CloseAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CloseAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseAccount_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CloseAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseAccount_Reply.Merge(m, src)
}

func (m *CloseAccount_Reply) XXX_Size() int {
	return m.Size()
}

func (m *CloseAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_CloseAccount_Reply proto.InternalMessageInfo

type CloseAccountWithProgress struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseAccountWithProgress) Reset()         { *m = CloseAccountWithProgress{} }
func (m *CloseAccountWithProgress) String() string { return proto.CompactTextString(m) }
func (*CloseAccountWithProgress) ProtoMessage()    {}
func (*CloseAccountWithProgress) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{3}
}

func (m *CloseAccountWithProgress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CloseAccountWithProgress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseAccountWithProgress.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CloseAccountWithProgress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseAccountWithProgress.Merge(m, src)
}

func (m *CloseAccountWithProgress) XXX_Size() int {
	return m.Size()
}

func (m *CloseAccountWithProgress) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseAccountWithProgress.DiscardUnknown(m)
}

var xxx_messageInfo_CloseAccountWithProgress proto.InternalMessageInfo

type CloseAccountWithProgress_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseAccountWithProgress_Request) Reset()         { *m = CloseAccountWithProgress_Request{} }
func (m *CloseAccountWithProgress_Request) String() string { return proto.CompactTextString(m) }
func (*CloseAccountWithProgress_Request) ProtoMessage()    {}
func (*CloseAccountWithProgress_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{3, 0}
}

func (m *CloseAccountWithProgress_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CloseAccountWithProgress_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseAccountWithProgress_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CloseAccountWithProgress_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseAccountWithProgress_Request.Merge(m, src)
}

func (m *CloseAccountWithProgress_Request) XXX_Size() int {
	return m.Size()
}

func (m *CloseAccountWithProgress_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseAccountWithProgress_Request.DiscardUnknown(m)
}

var xxx_messageInfo_CloseAccountWithProgress_Request proto.InternalMessageInfo

type CloseAccountWithProgress_Reply struct {
	Progress             *protocoltypes.Progress `protobuf:"bytes,1,opt,name=progress,proto3" json:"progress,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *CloseAccountWithProgress_Reply) Reset()         { *m = CloseAccountWithProgress_Reply{} }
func (m *CloseAccountWithProgress_Reply) String() string { return proto.CompactTextString(m) }
func (*CloseAccountWithProgress_Reply) ProtoMessage()    {}
func (*CloseAccountWithProgress_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{3, 1}
}

func (m *CloseAccountWithProgress_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CloseAccountWithProgress_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseAccountWithProgress_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CloseAccountWithProgress_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseAccountWithProgress_Reply.Merge(m, src)
}

func (m *CloseAccountWithProgress_Reply) XXX_Size() int {
	return m.Size()
}

func (m *CloseAccountWithProgress_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseAccountWithProgress_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_CloseAccountWithProgress_Reply proto.InternalMessageInfo

func (m *CloseAccountWithProgress_Reply) GetProgress() *protocoltypes.Progress {
	if m != nil {
		return m.Progress
	}
	return nil
}

type AccountMetadata struct {
	AccountID            string   `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	AvatarCID            string   `protobuf:"bytes,3,opt,name=avatar_cid,json=avatarCid,proto3" json:"avatar_cid,omitempty"`
	PublicKey            string   `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	LastOpened           int64    `protobuf:"varint,5,opt,name=last_opened,json=lastOpened,proto3" json:"last_opened,omitempty"`
	CreationDate         int64    `protobuf:"varint,6,opt,name=creation_date,json=creationDate,proto3" json:"creation_date,omitempty"`
	Error                string   `protobuf:"bytes,7,opt,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountMetadata) Reset()         { *m = AccountMetadata{} }
func (m *AccountMetadata) String() string { return proto.CompactTextString(m) }
func (*AccountMetadata) ProtoMessage()    {}
func (*AccountMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{4}
}

func (m *AccountMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *AccountMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AccountMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *AccountMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountMetadata.Merge(m, src)
}

func (m *AccountMetadata) XXX_Size() int {
	return m.Size()
}

func (m *AccountMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_AccountMetadata proto.InternalMessageInfo

func (m *AccountMetadata) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

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

func (m *AccountMetadata) GetAvatarCID() string {
	if m != nil {
		return m.AvatarCID
	}
	return ""
}

func (m *AccountMetadata) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

func (m *AccountMetadata) GetLastOpened() int64 {
	if m != nil {
		return m.LastOpened
	}
	return 0
}

func (m *AccountMetadata) GetCreationDate() int64 {
	if m != nil {
		return m.CreationDate
	}
	return 0
}

func (m *AccountMetadata) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type ListAccounts struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListAccounts) Reset()         { *m = ListAccounts{} }
func (m *ListAccounts) String() string { return proto.CompactTextString(m) }
func (*ListAccounts) ProtoMessage()    {}
func (*ListAccounts) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{5}
}

func (m *ListAccounts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ListAccounts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListAccounts.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ListAccounts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListAccounts.Merge(m, src)
}

func (m *ListAccounts) XXX_Size() int {
	return m.Size()
}

func (m *ListAccounts) XXX_DiscardUnknown() {
	xxx_messageInfo_ListAccounts.DiscardUnknown(m)
}

var xxx_messageInfo_ListAccounts proto.InternalMessageInfo

type ListAccounts_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListAccounts_Request) Reset()         { *m = ListAccounts_Request{} }
func (m *ListAccounts_Request) String() string { return proto.CompactTextString(m) }
func (*ListAccounts_Request) ProtoMessage()    {}
func (*ListAccounts_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{5, 0}
}

func (m *ListAccounts_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ListAccounts_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListAccounts_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ListAccounts_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListAccounts_Request.Merge(m, src)
}

func (m *ListAccounts_Request) XXX_Size() int {
	return m.Size()
}

func (m *ListAccounts_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ListAccounts_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ListAccounts_Request proto.InternalMessageInfo

type ListAccounts_Reply struct {
	Accounts             []*AccountMetadata `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *ListAccounts_Reply) Reset()         { *m = ListAccounts_Reply{} }
func (m *ListAccounts_Reply) String() string { return proto.CompactTextString(m) }
func (*ListAccounts_Reply) ProtoMessage()    {}
func (*ListAccounts_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{5, 1}
}

func (m *ListAccounts_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ListAccounts_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListAccounts_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ListAccounts_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListAccounts_Reply.Merge(m, src)
}

func (m *ListAccounts_Reply) XXX_Size() int {
	return m.Size()
}

func (m *ListAccounts_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_ListAccounts_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_ListAccounts_Reply proto.InternalMessageInfo

func (m *ListAccounts_Reply) GetAccounts() []*AccountMetadata {
	if m != nil {
		return m.Accounts
	}
	return nil
}

type DeleteAccount struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteAccount) Reset()         { *m = DeleteAccount{} }
func (m *DeleteAccount) String() string { return proto.CompactTextString(m) }
func (*DeleteAccount) ProtoMessage()    {}
func (*DeleteAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{6}
}

func (m *DeleteAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *DeleteAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *DeleteAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteAccount.Merge(m, src)
}

func (m *DeleteAccount) XXX_Size() int {
	return m.Size()
}

func (m *DeleteAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteAccount.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteAccount proto.InternalMessageInfo

type DeleteAccount_Request struct {
	AccountID            string   `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteAccount_Request) Reset()         { *m = DeleteAccount_Request{} }
func (m *DeleteAccount_Request) String() string { return proto.CompactTextString(m) }
func (*DeleteAccount_Request) ProtoMessage()    {}
func (*DeleteAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{6, 0}
}

func (m *DeleteAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *DeleteAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteAccount_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *DeleteAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteAccount_Request.Merge(m, src)
}

func (m *DeleteAccount_Request) XXX_Size() int {
	return m.Size()
}

func (m *DeleteAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteAccount_Request proto.InternalMessageInfo

func (m *DeleteAccount_Request) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

type DeleteAccount_Reply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteAccount_Reply) Reset()         { *m = DeleteAccount_Reply{} }
func (m *DeleteAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*DeleteAccount_Reply) ProtoMessage()    {}
func (*DeleteAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{6, 1}
}

func (m *DeleteAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *DeleteAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteAccount_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *DeleteAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteAccount_Reply.Merge(m, src)
}

func (m *DeleteAccount_Reply) XXX_Size() int {
	return m.Size()
}

func (m *DeleteAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteAccount_Reply proto.InternalMessageInfo

type ImportAccount struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ImportAccount) Reset()         { *m = ImportAccount{} }
func (m *ImportAccount) String() string { return proto.CompactTextString(m) }
func (*ImportAccount) ProtoMessage()    {}
func (*ImportAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{7}
}

func (m *ImportAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ImportAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ImportAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ImportAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportAccount.Merge(m, src)
}

func (m *ImportAccount) XXX_Size() int {
	return m.Size()
}

func (m *ImportAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportAccount.DiscardUnknown(m)
}

var xxx_messageInfo_ImportAccount proto.InternalMessageInfo

type ImportAccount_Request struct {
	AccountID            string   `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	AccountName          string   `protobuf:"bytes,2,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"`
	BackupPath           string   `protobuf:"bytes,3,opt,name=backup_path,json=backupPath,proto3" json:"backup_path,omitempty"`
	Args                 []string `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
	LoggerFilters        string   `protobuf:"bytes,5,opt,name=logger_filters,json=loggerFilters,proto3" json:"logger_filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ImportAccount_Request) Reset()         { *m = ImportAccount_Request{} }
func (m *ImportAccount_Request) String() string { return proto.CompactTextString(m) }
func (*ImportAccount_Request) ProtoMessage()    {}
func (*ImportAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{7, 0}
}

func (m *ImportAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ImportAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ImportAccount_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ImportAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportAccount_Request.Merge(m, src)
}

func (m *ImportAccount_Request) XXX_Size() int {
	return m.Size()
}

func (m *ImportAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ImportAccount_Request proto.InternalMessageInfo

func (m *ImportAccount_Request) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

func (m *ImportAccount_Request) GetAccountName() string {
	if m != nil {
		return m.AccountName
	}
	return ""
}

func (m *ImportAccount_Request) GetBackupPath() string {
	if m != nil {
		return m.BackupPath
	}
	return ""
}

func (m *ImportAccount_Request) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *ImportAccount_Request) GetLoggerFilters() string {
	if m != nil {
		return m.LoggerFilters
	}
	return ""
}

type ImportAccount_Reply struct {
	AccountMetadata      *AccountMetadata `protobuf:"bytes,1,opt,name=account_metadata,json=accountMetadata,proto3" json:"account_metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ImportAccount_Reply) Reset()         { *m = ImportAccount_Reply{} }
func (m *ImportAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*ImportAccount_Reply) ProtoMessage()    {}
func (*ImportAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{7, 1}
}

func (m *ImportAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ImportAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ImportAccount_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *ImportAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ImportAccount_Reply.Merge(m, src)
}

func (m *ImportAccount_Reply) XXX_Size() int {
	return m.Size()
}

func (m *ImportAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_ImportAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_ImportAccount_Reply proto.InternalMessageInfo

func (m *ImportAccount_Reply) GetAccountMetadata() *AccountMetadata {
	if m != nil {
		return m.AccountMetadata
	}
	return nil
}

type CreateAccount struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateAccount) Reset()         { *m = CreateAccount{} }
func (m *CreateAccount) String() string { return proto.CompactTextString(m) }
func (*CreateAccount) ProtoMessage()    {}
func (*CreateAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{8}
}

func (m *CreateAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CreateAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CreateAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateAccount.Merge(m, src)
}

func (m *CreateAccount) XXX_Size() int {
	return m.Size()
}

func (m *CreateAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateAccount.DiscardUnknown(m)
}

var xxx_messageInfo_CreateAccount proto.InternalMessageInfo

type CreateAccount_Request struct {
	AccountID            string   `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	AccountName          string   `protobuf:"bytes,2,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"`
	Args                 []string `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	LoggerFilters        string   `protobuf:"bytes,4,opt,name=logger_filters,json=loggerFilters,proto3" json:"logger_filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateAccount_Request) Reset()         { *m = CreateAccount_Request{} }
func (m *CreateAccount_Request) String() string { return proto.CompactTextString(m) }
func (*CreateAccount_Request) ProtoMessage()    {}
func (*CreateAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{8, 0}
}

func (m *CreateAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CreateAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateAccount_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CreateAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateAccount_Request.Merge(m, src)
}

func (m *CreateAccount_Request) XXX_Size() int {
	return m.Size()
}

func (m *CreateAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_CreateAccount_Request proto.InternalMessageInfo

func (m *CreateAccount_Request) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

func (m *CreateAccount_Request) GetAccountName() string {
	if m != nil {
		return m.AccountName
	}
	return ""
}

func (m *CreateAccount_Request) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *CreateAccount_Request) GetLoggerFilters() string {
	if m != nil {
		return m.LoggerFilters
	}
	return ""
}

type CreateAccount_Reply struct {
	AccountMetadata      *AccountMetadata `protobuf:"bytes,1,opt,name=account_metadata,json=accountMetadata,proto3" json:"account_metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *CreateAccount_Reply) Reset()         { *m = CreateAccount_Reply{} }
func (m *CreateAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*CreateAccount_Reply) ProtoMessage()    {}
func (*CreateAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{8, 1}
}

func (m *CreateAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *CreateAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateAccount_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *CreateAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateAccount_Reply.Merge(m, src)
}

func (m *CreateAccount_Reply) XXX_Size() int {
	return m.Size()
}

func (m *CreateAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_CreateAccount_Reply proto.InternalMessageInfo

func (m *CreateAccount_Reply) GetAccountMetadata() *AccountMetadata {
	if m != nil {
		return m.AccountMetadata
	}
	return nil
}

type UpdateAccount struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateAccount) Reset()         { *m = UpdateAccount{} }
func (m *UpdateAccount) String() string { return proto.CompactTextString(m) }
func (*UpdateAccount) ProtoMessage()    {}
func (*UpdateAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{9}
}

func (m *UpdateAccount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *UpdateAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateAccount.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *UpdateAccount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateAccount.Merge(m, src)
}

func (m *UpdateAccount) XXX_Size() int {
	return m.Size()
}

func (m *UpdateAccount) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateAccount.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateAccount proto.InternalMessageInfo

type UpdateAccount_Request struct {
	AccountID            string   `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	AccountName          string   `protobuf:"bytes,2,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"`
	AvatarCID            string   `protobuf:"bytes,3,opt,name=avatar_cid,json=avatarCid,proto3" json:"avatar_cid,omitempty"`
	PublicKey            string   `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateAccount_Request) Reset()         { *m = UpdateAccount_Request{} }
func (m *UpdateAccount_Request) String() string { return proto.CompactTextString(m) }
func (*UpdateAccount_Request) ProtoMessage()    {}
func (*UpdateAccount_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{9, 0}
}

func (m *UpdateAccount_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *UpdateAccount_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateAccount_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *UpdateAccount_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateAccount_Request.Merge(m, src)
}

func (m *UpdateAccount_Request) XXX_Size() int {
	return m.Size()
}

func (m *UpdateAccount_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateAccount_Request.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateAccount_Request proto.InternalMessageInfo

func (m *UpdateAccount_Request) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

func (m *UpdateAccount_Request) GetAccountName() string {
	if m != nil {
		return m.AccountName
	}
	return ""
}

func (m *UpdateAccount_Request) GetAvatarCID() string {
	if m != nil {
		return m.AvatarCID
	}
	return ""
}

func (m *UpdateAccount_Request) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

type UpdateAccount_Reply struct {
	AccountMetadata      *AccountMetadata `protobuf:"bytes,1,opt,name=account_metadata,json=accountMetadata,proto3" json:"account_metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *UpdateAccount_Reply) Reset()         { *m = UpdateAccount_Reply{} }
func (m *UpdateAccount_Reply) String() string { return proto.CompactTextString(m) }
func (*UpdateAccount_Reply) ProtoMessage()    {}
func (*UpdateAccount_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{9, 1}
}

func (m *UpdateAccount_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *UpdateAccount_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateAccount_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *UpdateAccount_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateAccount_Reply.Merge(m, src)
}

func (m *UpdateAccount_Reply) XXX_Size() int {
	return m.Size()
}

func (m *UpdateAccount_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateAccount_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateAccount_Reply proto.InternalMessageInfo

func (m *UpdateAccount_Reply) GetAccountMetadata() *AccountMetadata {
	if m != nil {
		return m.AccountMetadata
	}
	return nil
}

type GetGRPCListenerAddrs struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetGRPCListenerAddrs) Reset()         { *m = GetGRPCListenerAddrs{} }
func (m *GetGRPCListenerAddrs) String() string { return proto.CompactTextString(m) }
func (*GetGRPCListenerAddrs) ProtoMessage()    {}
func (*GetGRPCListenerAddrs) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{10}
}

func (m *GetGRPCListenerAddrs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *GetGRPCListenerAddrs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGRPCListenerAddrs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *GetGRPCListenerAddrs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGRPCListenerAddrs.Merge(m, src)
}

func (m *GetGRPCListenerAddrs) XXX_Size() int {
	return m.Size()
}

func (m *GetGRPCListenerAddrs) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGRPCListenerAddrs.DiscardUnknown(m)
}

var xxx_messageInfo_GetGRPCListenerAddrs proto.InternalMessageInfo

type GetGRPCListenerAddrs_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetGRPCListenerAddrs_Request) Reset()         { *m = GetGRPCListenerAddrs_Request{} }
func (m *GetGRPCListenerAddrs_Request) String() string { return proto.CompactTextString(m) }
func (*GetGRPCListenerAddrs_Request) ProtoMessage()    {}
func (*GetGRPCListenerAddrs_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{10, 0}
}

func (m *GetGRPCListenerAddrs_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *GetGRPCListenerAddrs_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGRPCListenerAddrs_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *GetGRPCListenerAddrs_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGRPCListenerAddrs_Request.Merge(m, src)
}

func (m *GetGRPCListenerAddrs_Request) XXX_Size() int {
	return m.Size()
}

func (m *GetGRPCListenerAddrs_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGRPCListenerAddrs_Request.DiscardUnknown(m)
}

var xxx_messageInfo_GetGRPCListenerAddrs_Request proto.InternalMessageInfo

type GetGRPCListenerAddrs_Reply struct {
	Entries              []*GetGRPCListenerAddrs_Reply_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (m *GetGRPCListenerAddrs_Reply) Reset()         { *m = GetGRPCListenerAddrs_Reply{} }
func (m *GetGRPCListenerAddrs_Reply) String() string { return proto.CompactTextString(m) }
func (*GetGRPCListenerAddrs_Reply) ProtoMessage()    {}
func (*GetGRPCListenerAddrs_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{10, 1}
}

func (m *GetGRPCListenerAddrs_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *GetGRPCListenerAddrs_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGRPCListenerAddrs_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *GetGRPCListenerAddrs_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGRPCListenerAddrs_Reply.Merge(m, src)
}

func (m *GetGRPCListenerAddrs_Reply) XXX_Size() int {
	return m.Size()
}

func (m *GetGRPCListenerAddrs_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGRPCListenerAddrs_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_GetGRPCListenerAddrs_Reply proto.InternalMessageInfo

func (m *GetGRPCListenerAddrs_Reply) GetEntries() []*GetGRPCListenerAddrs_Reply_Entry {
	if m != nil {
		return m.Entries
	}
	return nil
}

type GetGRPCListenerAddrs_Reply_Entry struct {
	Proto                string   `protobuf:"bytes,1,opt,name=proto,proto3" json:"proto,omitempty"`
	Maddr                string   `protobuf:"bytes,2,opt,name=maddr,proto3" json:"maddr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetGRPCListenerAddrs_Reply_Entry) Reset()         { *m = GetGRPCListenerAddrs_Reply_Entry{} }
func (m *GetGRPCListenerAddrs_Reply_Entry) String() string { return proto.CompactTextString(m) }
func (*GetGRPCListenerAddrs_Reply_Entry) ProtoMessage()    {}
func (*GetGRPCListenerAddrs_Reply_Entry) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{10, 1, 0}
}

func (m *GetGRPCListenerAddrs_Reply_Entry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *GetGRPCListenerAddrs_Reply_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetGRPCListenerAddrs_Reply_Entry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *GetGRPCListenerAddrs_Reply_Entry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetGRPCListenerAddrs_Reply_Entry.Merge(m, src)
}

func (m *GetGRPCListenerAddrs_Reply_Entry) XXX_Size() int {
	return m.Size()
}

func (m *GetGRPCListenerAddrs_Reply_Entry) XXX_DiscardUnknown() {
	xxx_messageInfo_GetGRPCListenerAddrs_Reply_Entry.DiscardUnknown(m)
}

var xxx_messageInfo_GetGRPCListenerAddrs_Reply_Entry proto.InternalMessageInfo

func (m *GetGRPCListenerAddrs_Reply_Entry) GetProto() string {
	if m != nil {
		return m.Proto
	}
	return ""
}

func (m *GetGRPCListenerAddrs_Reply_Entry) GetMaddr() string {
	if m != nil {
		return m.Maddr
	}
	return ""
}

type LogfileList struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LogfileList) Reset()         { *m = LogfileList{} }
func (m *LogfileList) String() string { return proto.CompactTextString(m) }
func (*LogfileList) ProtoMessage()    {}
func (*LogfileList) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{11}
}

func (m *LogfileList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *LogfileList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogfileList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *LogfileList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogfileList.Merge(m, src)
}

func (m *LogfileList) XXX_Size() int {
	return m.Size()
}

func (m *LogfileList) XXX_DiscardUnknown() {
	xxx_messageInfo_LogfileList.DiscardUnknown(m)
}

var xxx_messageInfo_LogfileList proto.InternalMessageInfo

type LogfileList_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LogfileList_Request) Reset()         { *m = LogfileList_Request{} }
func (m *LogfileList_Request) String() string { return proto.CompactTextString(m) }
func (*LogfileList_Request) ProtoMessage()    {}
func (*LogfileList_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{11, 0}
}

func (m *LogfileList_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *LogfileList_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogfileList_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *LogfileList_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogfileList_Request.Merge(m, src)
}

func (m *LogfileList_Request) XXX_Size() int {
	return m.Size()
}

func (m *LogfileList_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_LogfileList_Request.DiscardUnknown(m)
}

var xxx_messageInfo_LogfileList_Request proto.InternalMessageInfo

type LogfileList_Reply struct {
	Entries              []*LogfileList_Reply_Logfile `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *LogfileList_Reply) Reset()         { *m = LogfileList_Reply{} }
func (m *LogfileList_Reply) String() string { return proto.CompactTextString(m) }
func (*LogfileList_Reply) ProtoMessage()    {}
func (*LogfileList_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{11, 1}
}

func (m *LogfileList_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *LogfileList_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogfileList_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *LogfileList_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogfileList_Reply.Merge(m, src)
}

func (m *LogfileList_Reply) XXX_Size() int {
	return m.Size()
}

func (m *LogfileList_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_LogfileList_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_LogfileList_Reply proto.InternalMessageInfo

func (m *LogfileList_Reply) GetEntries() []*LogfileList_Reply_Logfile {
	if m != nil {
		return m.Entries
	}
	return nil
}

type LogfileList_Reply_Logfile struct {
	AccountID            string   `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Path                 string   `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	Size_                int64    `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	Kind                 string   `protobuf:"bytes,5,opt,name=kind,proto3" json:"kind,omitempty"`
	Time                 int64    `protobuf:"varint,6,opt,name=time,proto3" json:"time,omitempty"`
	Latest               bool     `protobuf:"varint,7,opt,name=latest,proto3" json:"latest,omitempty"`
	Errs                 string   `protobuf:"bytes,8,opt,name=errs,proto3" json:"errs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LogfileList_Reply_Logfile) Reset()         { *m = LogfileList_Reply_Logfile{} }
func (m *LogfileList_Reply_Logfile) String() string { return proto.CompactTextString(m) }
func (*LogfileList_Reply_Logfile) ProtoMessage()    {}
func (*LogfileList_Reply_Logfile) Descriptor() ([]byte, []int) {
	return fileDescriptor_2e9b7fcde47f62fe, []int{11, 1, 0}
}

func (m *LogfileList_Reply_Logfile) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *LogfileList_Reply_Logfile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogfileList_Reply_Logfile.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}

func (m *LogfileList_Reply_Logfile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogfileList_Reply_Logfile.Merge(m, src)
}

func (m *LogfileList_Reply_Logfile) XXX_Size() int {
	return m.Size()
}

func (m *LogfileList_Reply_Logfile) XXX_DiscardUnknown() {
	xxx_messageInfo_LogfileList_Reply_Logfile.DiscardUnknown(m)
}

var xxx_messageInfo_LogfileList_Reply_Logfile proto.InternalMessageInfo

func (m *LogfileList_Reply_Logfile) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

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

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

func (m *LogfileList_Reply_Logfile) GetSize_() int64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *LogfileList_Reply_Logfile) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *LogfileList_Reply_Logfile) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *LogfileList_Reply_Logfile) GetLatest() bool {
	if m != nil {
		return m.Latest
	}
	return false
}

func (m *LogfileList_Reply_Logfile) GetErrs() string {
	if m != nil {
		return m.Errs
	}
	return ""
}

func init() {
	proto.RegisterType((*OpenAccount)(nil), "berty.account.v1.OpenAccount")
	proto.RegisterType((*OpenAccount_Request)(nil), "berty.account.v1.OpenAccount.Request")
	proto.RegisterType((*OpenAccount_Reply)(nil), "berty.account.v1.OpenAccount.Reply")
	proto.RegisterType((*OpenAccountWithProgress)(nil), "berty.account.v1.OpenAccountWithProgress")
	proto.RegisterType((*OpenAccountWithProgress_Request)(nil), "berty.account.v1.OpenAccountWithProgress.Request")
	proto.RegisterType((*OpenAccountWithProgress_Reply)(nil), "berty.account.v1.OpenAccountWithProgress.Reply")
	proto.RegisterType((*CloseAccount)(nil), "berty.account.v1.CloseAccount")
	proto.RegisterType((*CloseAccount_Request)(nil), "berty.account.v1.CloseAccount.Request")
	proto.RegisterType((*CloseAccount_Reply)(nil), "berty.account.v1.CloseAccount.Reply")
	proto.RegisterType((*CloseAccountWithProgress)(nil), "berty.account.v1.CloseAccountWithProgress")
	proto.RegisterType((*CloseAccountWithProgress_Request)(nil), "berty.account.v1.CloseAccountWithProgress.Request")
	proto.RegisterType((*CloseAccountWithProgress_Reply)(nil), "berty.account.v1.CloseAccountWithProgress.Reply")
	proto.RegisterType((*AccountMetadata)(nil), "berty.account.v1.AccountMetadata")
	proto.RegisterType((*ListAccounts)(nil), "berty.account.v1.ListAccounts")
	proto.RegisterType((*ListAccounts_Request)(nil), "berty.account.v1.ListAccounts.Request")
	proto.RegisterType((*ListAccounts_Reply)(nil), "berty.account.v1.ListAccounts.Reply")
	proto.RegisterType((*DeleteAccount)(nil), "berty.account.v1.DeleteAccount")
	proto.RegisterType((*DeleteAccount_Request)(nil), "berty.account.v1.DeleteAccount.Request")
	proto.RegisterType((*DeleteAccount_Reply)(nil), "berty.account.v1.DeleteAccount.Reply")
	proto.RegisterType((*ImportAccount)(nil), "berty.account.v1.ImportAccount")
	proto.RegisterType((*ImportAccount_Request)(nil), "berty.account.v1.ImportAccount.Request")
	proto.RegisterType((*ImportAccount_Reply)(nil), "berty.account.v1.ImportAccount.Reply")
	proto.RegisterType((*CreateAccount)(nil), "berty.account.v1.CreateAccount")
	proto.RegisterType((*CreateAccount_Request)(nil), "berty.account.v1.CreateAccount.Request")
	proto.RegisterType((*CreateAccount_Reply)(nil), "berty.account.v1.CreateAccount.Reply")
	proto.RegisterType((*UpdateAccount)(nil), "berty.account.v1.UpdateAccount")
	proto.RegisterType((*UpdateAccount_Request)(nil), "berty.account.v1.UpdateAccount.Request")
	proto.RegisterType((*UpdateAccount_Reply)(nil), "berty.account.v1.UpdateAccount.Reply")
	proto.RegisterType((*GetGRPCListenerAddrs)(nil), "berty.account.v1.GetGRPCListenerAddrs")
	proto.RegisterType((*GetGRPCListenerAddrs_Request)(nil), "berty.account.v1.GetGRPCListenerAddrs.Request")
	proto.RegisterType((*GetGRPCListenerAddrs_Reply)(nil), "berty.account.v1.GetGRPCListenerAddrs.Reply")
	proto.RegisterType((*GetGRPCListenerAddrs_Reply_Entry)(nil), "berty.account.v1.GetGRPCListenerAddrs.Reply.Entry")
	proto.RegisterType((*LogfileList)(nil), "berty.account.v1.LogfileList")
	proto.RegisterType((*LogfileList_Request)(nil), "berty.account.v1.LogfileList.Request")
	proto.RegisterType((*LogfileList_Reply)(nil), "berty.account.v1.LogfileList.Reply")
	proto.RegisterType((*LogfileList_Reply_Logfile)(nil), "berty.account.v1.LogfileList.Reply.Logfile")
}

func init() { proto.RegisterFile("bertyaccount.proto", fileDescriptor_2e9b7fcde47f62fe) }

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ grpc.ClientConn
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AccountServiceClient is the client API for AccountService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AccountServiceClient interface {
	// OpenAccount starts a Berty node.
	OpenAccount(ctx context.Context, in *OpenAccount_Request, opts ...grpc.CallOption) (*OpenAccount_Reply, error)
	// OpenAccountWithProgress is similar to OpenAccount, but also streams the progress.
	OpenAccountWithProgress(ctx context.Context, in *OpenAccountWithProgress_Request, opts ...grpc.CallOption) (AccountService_OpenAccountWithProgressClient, error)
	// CloseAccount closes the currently opened account.
	CloseAccount(ctx context.Context, in *CloseAccount_Request, opts ...grpc.CallOption) (*CloseAccount_Reply, error)
	// CloseAccountWithProgress is similar to CloseAccount, but also streams the progress.
	CloseAccountWithProgress(ctx context.Context, in *CloseAccountWithProgress_Request, opts ...grpc.CallOption) (AccountService_CloseAccountWithProgressClient, error)
	// ListAccounts retrieves a list of local accounts.
	ListAccounts(ctx context.Context, in *ListAccounts_Request, opts ...grpc.CallOption) (*ListAccounts_Reply, error)
	// DeleteAccount deletes an account.
	DeleteAccount(ctx context.Context, in *DeleteAccount_Request, opts ...grpc.CallOption) (*DeleteAccount_Reply, error)
	// ImportAccount imports existing data.
	ImportAccount(ctx context.Context, in *ImportAccount_Request, opts ...grpc.CallOption) (*ImportAccount_Reply, error)
	// CreateAccount creates a new account.
	CreateAccount(ctx context.Context, in *CreateAccount_Request, opts ...grpc.CallOption) (*CreateAccount_Reply, error)
	// UpdateAccount update account's metadata.
	UpdateAccount(ctx context.Context, in *UpdateAccount_Request, opts ...grpc.CallOption) (*UpdateAccount_Reply, error)
	// GetGRPCListenerAddrs return current listeners addrs available on this bridge.
	GetGRPCListenerAddrs(ctx context.Context, in *GetGRPCListenerAddrs_Request, opts ...grpc.CallOption) (*GetGRPCListenerAddrs_Reply, error)
	// LogfileList returns a list of logfiles that can be used with Tyber.
	LogfileList(ctx context.Context, in *LogfileList_Request, opts ...grpc.CallOption) (*LogfileList_Reply, error)
}

type accountServiceClient struct {
	cc *grpc.ClientConn
}

func NewAccountServiceClient(cc *grpc.ClientConn) AccountServiceClient {
	return &accountServiceClient{cc}
}

func (c *accountServiceClient) OpenAccount(ctx context.Context, in *OpenAccount_Request, opts ...grpc.CallOption) (*OpenAccount_Reply, error) {
	out := new(OpenAccount_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/OpenAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) OpenAccountWithProgress(ctx context.Context, in *OpenAccountWithProgress_Request, opts ...grpc.CallOption) (AccountService_OpenAccountWithProgressClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AccountService_serviceDesc.Streams[0], "/berty.account.v1.AccountService/OpenAccountWithProgress", opts...)
	if err != nil {
		return nil, err
	}
	x := &accountServiceOpenAccountWithProgressClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AccountService_OpenAccountWithProgressClient interface {
	Recv() (*OpenAccountWithProgress_Reply, error)
	grpc.ClientStream
}

type accountServiceOpenAccountWithProgressClient struct {
	grpc.ClientStream
}

func (x *accountServiceOpenAccountWithProgressClient) Recv() (*OpenAccountWithProgress_Reply, error) {
	m := new(OpenAccountWithProgress_Reply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *accountServiceClient) CloseAccount(ctx context.Context, in *CloseAccount_Request, opts ...grpc.CallOption) (*CloseAccount_Reply, error) {
	out := new(CloseAccount_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/CloseAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) CloseAccountWithProgress(ctx context.Context, in *CloseAccountWithProgress_Request, opts ...grpc.CallOption) (AccountService_CloseAccountWithProgressClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AccountService_serviceDesc.Streams[1], "/berty.account.v1.AccountService/CloseAccountWithProgress", opts...)
	if err != nil {
		return nil, err
	}
	x := &accountServiceCloseAccountWithProgressClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type AccountService_CloseAccountWithProgressClient interface {
	Recv() (*CloseAccountWithProgress_Reply, error)
	grpc.ClientStream
}

type accountServiceCloseAccountWithProgressClient struct {
	grpc.ClientStream
}

func (x *accountServiceCloseAccountWithProgressClient) Recv() (*CloseAccountWithProgress_Reply, error) {
	m := new(CloseAccountWithProgress_Reply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *accountServiceClient) ListAccounts(ctx context.Context, in *ListAccounts_Request, opts ...grpc.CallOption) (*ListAccounts_Reply, error) {
	out := new(ListAccounts_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/ListAccounts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) DeleteAccount(ctx context.Context, in *DeleteAccount_Request, opts ...grpc.CallOption) (*DeleteAccount_Reply, error) {
	out := new(DeleteAccount_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/DeleteAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) ImportAccount(ctx context.Context, in *ImportAccount_Request, opts ...grpc.CallOption) (*ImportAccount_Reply, error) {
	out := new(ImportAccount_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/ImportAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) CreateAccount(ctx context.Context, in *CreateAccount_Request, opts ...grpc.CallOption) (*CreateAccount_Reply, error) {
	out := new(CreateAccount_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/CreateAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) UpdateAccount(ctx context.Context, in *UpdateAccount_Request, opts ...grpc.CallOption) (*UpdateAccount_Reply, error) {
	out := new(UpdateAccount_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/UpdateAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) GetGRPCListenerAddrs(ctx context.Context, in *GetGRPCListenerAddrs_Request, opts ...grpc.CallOption) (*GetGRPCListenerAddrs_Reply, error) {
	out := new(GetGRPCListenerAddrs_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/GetGRPCListenerAddrs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *accountServiceClient) LogfileList(ctx context.Context, in *LogfileList_Request, opts ...grpc.CallOption) (*LogfileList_Reply, error) {
	out := new(LogfileList_Reply)
	err := c.cc.Invoke(ctx, "/berty.account.v1.AccountService/LogfileList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AccountServiceServer is the server API for AccountService service.
type AccountServiceServer interface {
	// OpenAccount starts a Berty node.
	OpenAccount(context.Context, *OpenAccount_Request) (*OpenAccount_Reply, error)
	// OpenAccountWithProgress is similar to OpenAccount, but also streams the progress.
	OpenAccountWithProgress(*OpenAccountWithProgress_Request, AccountService_OpenAccountWithProgressServer) error
	// CloseAccount closes the currently opened account.
	CloseAccount(context.Context, *CloseAccount_Request) (*CloseAccount_Reply, error)
	// CloseAccountWithProgress is similar to CloseAccount, but also streams the progress.
	CloseAccountWithProgress(*CloseAccountWithProgress_Request, AccountService_CloseAccountWithProgressServer) error
	// ListAccounts retrieves a list of local accounts.
	ListAccounts(context.Context, *ListAccounts_Request) (*ListAccounts_Reply, error)
	// DeleteAccount deletes an account.
	DeleteAccount(context.Context, *DeleteAccount_Request) (*DeleteAccount_Reply, error)
	// ImportAccount imports existing data.
	ImportAccount(context.Context, *ImportAccount_Request) (*ImportAccount_Reply, error)
	// CreateAccount creates a new account.
	CreateAccount(context.Context, *CreateAccount_Request) (*CreateAccount_Reply, error)
	// UpdateAccount update account's metadata.
	UpdateAccount(context.Context, *UpdateAccount_Request) (*UpdateAccount_Reply, error)
	// GetGRPCListenerAddrs return current listeners addrs available on this bridge.
	GetGRPCListenerAddrs(context.Context, *GetGRPCListenerAddrs_Request) (*GetGRPCListenerAddrs_Reply, error)
	// LogfileList returns a list of logfiles that can be used with Tyber.
	LogfileList(context.Context, *LogfileList_Request) (*LogfileList_Reply, error)
}

// UnimplementedAccountServiceServer can be embedded to have forward compatible implementations.
type UnimplementedAccountServiceServer struct{}

func (*UnimplementedAccountServiceServer) OpenAccount(ctx context.Context, req *OpenAccount_Request) (*OpenAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenAccount not implemented")
}

func (*UnimplementedAccountServiceServer) OpenAccountWithProgress(req *OpenAccountWithProgress_Request, srv AccountService_OpenAccountWithProgressServer) error {
	return status.Errorf(codes.Unimplemented, "method OpenAccountWithProgress not implemented")
}

func (*UnimplementedAccountServiceServer) CloseAccount(ctx context.Context, req *CloseAccount_Request) (*CloseAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseAccount not implemented")
}

func (*UnimplementedAccountServiceServer) CloseAccountWithProgress(req *CloseAccountWithProgress_Request, srv AccountService_CloseAccountWithProgressServer) error {
	return status.Errorf(codes.Unimplemented, "method CloseAccountWithProgress not implemented")
}

func (*UnimplementedAccountServiceServer) ListAccounts(ctx context.Context, req *ListAccounts_Request) (*ListAccounts_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAccounts not implemented")
}

func (*UnimplementedAccountServiceServer) DeleteAccount(ctx context.Context, req *DeleteAccount_Request) (*DeleteAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAccount not implemented")
}

func (*UnimplementedAccountServiceServer) ImportAccount(ctx context.Context, req *ImportAccount_Request) (*ImportAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportAccount not implemented")
}

func (*UnimplementedAccountServiceServer) CreateAccount(ctx context.Context, req *CreateAccount_Request) (*CreateAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAccount not implemented")
}

func (*UnimplementedAccountServiceServer) UpdateAccount(ctx context.Context, req *UpdateAccount_Request) (*UpdateAccount_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAccount not implemented")
}

func (*UnimplementedAccountServiceServer) GetGRPCListenerAddrs(ctx context.Context, req *GetGRPCListenerAddrs_Request) (*GetGRPCListenerAddrs_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetGRPCListenerAddrs not implemented")
}

func (*UnimplementedAccountServiceServer) LogfileList(ctx context.Context, req *LogfileList_Request) (*LogfileList_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LogfileList not implemented")
}

func RegisterAccountServiceServer(s *grpc.Server, srv AccountServiceServer) {
	s.RegisterService(&_AccountService_serviceDesc, srv)
}

func _AccountService_OpenAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OpenAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).OpenAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/OpenAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).OpenAccount(ctx, req.(*OpenAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_OpenAccountWithProgress_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(OpenAccountWithProgress_Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AccountServiceServer).OpenAccountWithProgress(m, &accountServiceOpenAccountWithProgressServer{stream})
}

type AccountService_OpenAccountWithProgressServer interface {
	Send(*OpenAccountWithProgress_Reply) error
	grpc.ServerStream
}

type accountServiceOpenAccountWithProgressServer struct {
	grpc.ServerStream
}

func (x *accountServiceOpenAccountWithProgressServer) Send(m *OpenAccountWithProgress_Reply) error {
	return x.ServerStream.SendMsg(m)
}

func _AccountService_CloseAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloseAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).CloseAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/CloseAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).CloseAccount(ctx, req.(*CloseAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_CloseAccountWithProgress_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CloseAccountWithProgress_Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AccountServiceServer).CloseAccountWithProgress(m, &accountServiceCloseAccountWithProgressServer{stream})
}

type AccountService_CloseAccountWithProgressServer interface {
	Send(*CloseAccountWithProgress_Reply) error
	grpc.ServerStream
}

type accountServiceCloseAccountWithProgressServer struct {
	grpc.ServerStream
}

func (x *accountServiceCloseAccountWithProgressServer) Send(m *CloseAccountWithProgress_Reply) error {
	return x.ServerStream.SendMsg(m)
}

func _AccountService_ListAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAccounts_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).ListAccounts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/ListAccounts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).ListAccounts(ctx, req.(*ListAccounts_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_DeleteAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).DeleteAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/DeleteAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).DeleteAccount(ctx, req.(*DeleteAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_ImportAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).ImportAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/ImportAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).ImportAccount(ctx, req.(*ImportAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_CreateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).CreateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/CreateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).CreateAccount(ctx, req.(*CreateAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_UpdateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAccount_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).UpdateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/UpdateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).UpdateAccount(ctx, req.(*UpdateAccount_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_GetGRPCListenerAddrs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetGRPCListenerAddrs_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).GetGRPCListenerAddrs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/GetGRPCListenerAddrs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).GetGRPCListenerAddrs(ctx, req.(*GetGRPCListenerAddrs_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _AccountService_LogfileList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LogfileList_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AccountServiceServer).LogfileList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.account.v1.AccountService/LogfileList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AccountServiceServer).LogfileList(ctx, req.(*LogfileList_Request))
	}
	return interceptor(ctx, in, info, handler)
}

var _AccountService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "berty.account.v1.AccountService",
	HandlerType: (*AccountServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "OpenAccount",
			Handler:    _AccountService_OpenAccount_Handler,
		},
		{
			MethodName: "CloseAccount",
			Handler:    _AccountService_CloseAccount_Handler,
		},
		{
			MethodName: "ListAccounts",
			Handler:    _AccountService_ListAccounts_Handler,
		},
		{
			MethodName: "DeleteAccount",
			Handler:    _AccountService_DeleteAccount_Handler,
		},
		{
			MethodName: "ImportAccount",
			Handler:    _AccountService_ImportAccount_Handler,
		},
		{
			MethodName: "CreateAccount",
			Handler:    _AccountService_CreateAccount_Handler,
		},
		{
			MethodName: "UpdateAccount",
			Handler:    _AccountService_UpdateAccount_Handler,
		},
		{
			MethodName: "GetGRPCListenerAddrs",
			Handler:    _AccountService_GetGRPCListenerAddrs_Handler,
		},
		{
			MethodName: "LogfileList",
			Handler:    _AccountService_LogfileList_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "OpenAccountWithProgress",
			Handler:       _AccountService_OpenAccountWithProgress_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CloseAccountWithProgress",
			Handler:       _AccountService_CloseAccountWithProgress_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "bertyaccount.proto",
}

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

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

func (m *OpenAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OpenAccount_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.LoggerFilters)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Args[iNdEx])
			copy(dAtA[i:], m.Args[iNdEx])
			i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Args[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OpenAccount_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OpenAccountWithProgress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OpenAccountWithProgress_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.LoggerFilters)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Args[iNdEx])
			copy(dAtA[i:], m.Args[iNdEx])
			i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Args[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *CloseAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CloseAccount_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CloseAccount_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CloseAccountWithProgress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CloseAccountWithProgress_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AccountMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x3a
	}
	if m.CreationDate != 0 {
		i = encodeVarintBertyaccount(dAtA, i, uint64(m.CreationDate))
		i--
		dAtA[i] = 0x30
	}
	if m.LastOpened != 0 {
		i = encodeVarintBertyaccount(dAtA, i, uint64(m.LastOpened))
		i--
		dAtA[i] = 0x28
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.AvatarCID) > 0 {
		i -= len(m.AvatarCID)
		copy(dAtA[i:], m.AvatarCID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AvatarCID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ListAccounts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ListAccounts_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ListAccounts_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Accounts) > 0 {
		for iNdEx := len(m.Accounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Accounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBertyaccount(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DeleteAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DeleteAccount_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DeleteAccount_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ImportAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ImportAccount_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.LoggerFilters)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Args[iNdEx])
			copy(dAtA[i:], m.Args[iNdEx])
			i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Args[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.BackupPath) > 0 {
		i -= len(m.BackupPath)
		copy(dAtA[i:], m.BackupPath)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.BackupPath)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AccountName) > 0 {
		i -= len(m.AccountName)
		copy(dAtA[i:], m.AccountName)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *CreateAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CreateAccount_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.LoggerFilters) > 0 {
		i -= len(m.LoggerFilters)
		copy(dAtA[i:], m.LoggerFilters)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.LoggerFilters)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Args[iNdEx])
			copy(dAtA[i:], m.Args[iNdEx])
			i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Args[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.AccountName) > 0 {
		i -= len(m.AccountName)
		copy(dAtA[i:], m.AccountName)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *UpdateAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *UpdateAccount_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.AvatarCID) > 0 {
		i -= len(m.AvatarCID)
		copy(dAtA[i:], m.AvatarCID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AvatarCID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AccountName) > 0 {
		i -= len(m.AccountName)
		copy(dAtA[i:], m.AccountName)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *GetGRPCListenerAddrs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GetGRPCListenerAddrs_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GetGRPCListenerAddrs_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBertyaccount(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GetGRPCListenerAddrs_Reply_Entry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Maddr) > 0 {
		i -= len(m.Maddr)
		copy(dAtA[i:], m.Maddr)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Maddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Proto) > 0 {
		i -= len(m.Proto)
		copy(dAtA[i:], m.Proto)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Proto)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogfileList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogfileList_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogfileList_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBertyaccount(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogfileList_Reply_Logfile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Errs) > 0 {
		i -= len(m.Errs)
		copy(dAtA[i:], m.Errs)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Errs)))
		i--
		dAtA[i] = 0x42
	}
	if m.Latest {
		i--
		if m.Latest {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Time != 0 {
		i = encodeVarintBertyaccount(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Size_ != 0 {
		i = encodeVarintBertyaccount(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertyaccount(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintBertyaccount(dAtA []byte, offset int, v uint64) int {
	offset -= sovBertyaccount(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *OpenAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenAccount_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenAccount_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenAccountWithProgress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenAccountWithProgress_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OpenAccountWithProgress_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Progress != nil {
		l = m.Progress.Size()
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseAccount_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseAccount_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseAccountWithProgress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseAccountWithProgress_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CloseAccountWithProgress_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Progress != nil {
		l = m.Progress.Size()
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccountMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.AvatarCID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.LastOpened != 0 {
		n += 1 + sovBertyaccount(uint64(m.LastOpened))
	}
	if m.CreationDate != 0 {
		n += 1 + sovBertyaccount(uint64(m.CreationDate))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListAccounts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListAccounts_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListAccounts_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Accounts) > 0 {
		for _, e := range m.Accounts {
			l = e.Size()
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteAccount_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteAccount_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ImportAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ImportAccount_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.BackupPath)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ImportAccount_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountMetadata != nil {
		l = m.AccountMetadata.Size()
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateAccount_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	l = len(m.LoggerFilters)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateAccount_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountMetadata != nil {
		l = m.AccountMetadata.Size()
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateAccount_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.AvatarCID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateAccount_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountMetadata != nil {
		l = m.AccountMetadata.Size()
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetGRPCListenerAddrs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetGRPCListenerAddrs_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetGRPCListenerAddrs_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetGRPCListenerAddrs_Reply_Entry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Proto)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.Maddr)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LogfileList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LogfileList_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LogfileList_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovBertyaccount(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LogfileList_Reply_Logfile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovBertyaccount(uint64(m.Size_))
	}
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovBertyaccount(uint64(m.Time))
	}
	if m.Latest {
		n += 2
	}
	l = len(m.Errs)
	if l > 0 {
		n += 1 + l + sovBertyaccount(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovBertyaccount(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozBertyaccount(x uint64) (n int) {
	return sovBertyaccount(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *ImportAccount_Request) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertyaccount
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BackupPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BackupPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoggerFilters", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoggerFilters = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertyaccount(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

func (m *LogfileList_Reply_Logfile) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertyaccount
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Logfile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Logfile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountID = 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 ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			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 Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Latest", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Latest = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyaccount
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertyaccount
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Errs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertyaccount(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyaccount
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}

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

var (
	ErrInvalidLengthBertyaccount        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBertyaccount          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBertyaccount = fmt.Errorf("proto: unexpected end of group")
)